home *** CD-ROM | disk | FTP | other *** search
/ LSD Docs / LSD Docs.iso / FILEZ / lsd22.dms / lsd22.adf / AmigaLIBRARY.MAP.pp / AmigaLIBRARY.MAP
Text File  |  1990-09-07  |  251KB  |  6,781 lines
  1.  
  2. ------------------------- 
  3. Final Notes 
  4. There are a few macros included in the following function list. Accessing a 
  5. macro is much like accessing a library function. In Modula-2, all supported 
  6. macros are defined as standard procedures and placed into modules. With C 
  7. and machine language, they are actual compiler/assembler macros that must be 
  8. included in your source code. The include file, header file, and Modula-2 mod-
  9. ule that contains the macro definitions are included in the macro's table entry.
  10. A few last minute points should be made regarding the terminology used 
  11. in the following list of functions: By convention, a NULL value is equivalent to 
  12. 0. The Modula-2 equivalent of NULL is NIL, which is defined as ADDRESS(0). 
  13. In C, TRUE represents a nonzero value (usually equal to 1) and FALSE equals 
  14. 0. In Modula-2, TRUE and FALSE are elements of the type BOOLEAN. If you 
  15. see an _fptr in a C usage description, it specifies a pointer to a function.
  16. The following table is mainly for reference purposes-it's a place you can 
  17. look up information about any Amiga library function, quickly and easily. For 
  18. more details about using a specific function, we suggest you refer to the auto-
  19. docs section of the Commodore-Amiga ROM Kernel Reference Manual.
  20.  
  21. -------------------------Functions Start Here-------------------------
  22. AbortIO
  23. Description:         attempts to abort an I/O request already in progress
  24. Library:            exec.library
  25. Offset:             -$01E0 (-480)
  26. Modula-2 Module:     IO
  27. Syntax:                error = AbortIO(ioRequest)
  28. C:                    long AbortIO(struct IORequest *)
  29. Machine Language:     d0 = AbortIO(a1)
  30. Modula-2:        AbortIO(ioRequest: ADDRESS): LONGINT
  31. Arguments:        ioRequest = IORequest block containing I/O request to abort
  32. Result:            error = 0 if successful; nonzero error value if unsuccessful
  33. -------------------------
  34. ActivateGadget
  35. Description:        activates a string gadget so the user does not have to click in the
  36.             gadget box to bring up a cursor
  37. Library:        intuition.library
  38. Offset:            -$01CE (-462)
  39. Modula-2 Module:     Intuition
  40. Syntax:            success = ActivateGadget(gadget, window, requester)
  41. C:            long ActivateGadget(struct Gadget *, struct Window *, struct 
  42. Requester *)
  43. Machine Language:     d0 = ActivateGadget(a0, a1, a2)
  44. Modula-2:        ActivateGadget(gadget: GadgetPtr; window: WindowPtr; request-
  45.             er: RequesterPtr): BOOLEAN
  46. Arguments:        gadget = string gadget to activate
  47.             window = window containing gadget
  48.             requester = requester to receive gadgets; NULL if gadgets are not
  49.             to be part of a requester
  50. Result:            success = TRUE if successful; FALSE if arguments are bogus
  51. -------------------------
  52. ActivateWindow
  53. Description:        activates a window
  54. Library:        intuition.library
  55. Offset:            -$01C2 (-450)
  56. Modula-2 Module:     Intuition
  57. Syntax:                ActivateWindow(window)
  58. C:                    long ActivateWindow(struct Window *)
  59. Machine Language:     ActivateWindow(a0)
  60. Modula-2:        ActivateWindow(window: WindowPtr)
  61. Arguments:        window = window to activate
  62. Result:            none
  63. -------------------------
  64. AddAnimOb
  65. Description:        adds an AnimOb to the linked list of AnimObs
  66. Library:        graphics.library
  67. Modula-2 Module:     Gels
  68. Offset:             -$009C (-156)
  69. Syntax:                AddAnimOb(anOb, anKey, rastPort)
  70. C:                    void AddAnimOb(struct AnimOb *, long, struct RastPort *)
  71. Machine Language:     AddAnimOb(a0, a1, a2)
  72. Modula-2:        AddAnimOb(anOb: AnimObPtr; anKey: ADDRESS; rastPort:
  73.             RastPortPtr)
  74. Arguments:        anOb = AnimOb structure to be added to list
  75.             anKey = address of pointer to the first AnimOb in the list
  76.             (anKey=NULL if none in list so far)
  77.             rastPort = RastPort structure
  78. Result:            none
  79. -------------------------
  80. AddBob
  81. Description:         adds a Bob to GEL list
  82. Library:            graphics.library
  83. Offset:             -$0060 (-96)
  84. Modula-2 Module:     Gels
  85. Syntax:                AddBob(bob, rastPort)
  86. C:                   void AddBob(struct Bob *, struct RastPort *)
  87. Machine Language:     AddBob(a0, a1)
  88. Modula-2:        AddBob(bob: BobPtr; VAR rastPort: RastPortPtr)
  89. Arguments:        bob = Bob structure to be added to GEL list
  90.             rastPort = RastPort structure
  91. Result:            none
  92. -------------------------
  93. AddConfigDev
  94. Description:        adds a new ConfigDev structure to the system's list of configura-
  95.             tion devices
  96. Library:        expansion.library
  97. Offset:            -$001E (-30)
  98. Modula-2 Module:     ConfigVars
  99. Syntax:                AddConfigDev(configDev)
  100. C:                    void AddConfigDev(long)
  101. Machine Language:     AddConfigDev(a0)
  102. Modula-2:        AddConfigDev(configDev: ConfigDevPtr)
  103. Arguments:        configDef = a valid ConfigDev structure
  104. Result:            none
  105. -------------------------
  106. AddDevice
  107. Description:        adds a device to the system
  108. Library:        exec.library
  109. Offset:            -$01B0 (-432)
  110. Modula-2 Module:     Devices
  111. Syntax:                AddDevice(device)
  112. C:                    void AddDevice(struct Device *)
  113. Machine Language:     AddDevice(a1)
  114. Modula-2:              AddDevice(device: DevicePtr)
  115. Arguments:             device = initialized device node
  116. Result:            none
  117. -------------------------
  118. AddDosNode
  119. Description:         mounts a disk
  120. Library:            expansion.library
  121. Offset:             -$0096 (-150)
  122. Modula-2 Module:     Expansion
  123. Syntax:                AddDosNode(bootPri, flags, deviceNode)
  124. C:                    void AddDosNode(long, long, struct dosNode *)
  125. Machine Language:     AddDosNode(d0, d1, a0)
  126. Modula-2:        AddDosNode(bootPri: INTEGER; flags: BITSET; deviceNode:
  127.             DeviceNodePtr): BOOLEAN
  128. Arguments:        bootPri = boot priority of disk-+5 for floppy disk, 0 for hard
  129.             disk,-5 for a network disk,-128 non-bootable device
  130.             flags = ADN_STARTPROC (1) to start handler process
  131.             immediately
  132.             dosNode = initialized device node, as returned by
  133.             MakeDosNode( )
  134. Result:            none
  135. -------------------------
  136. AddFont
  137. Description:        adds a font to the system
  138. Library:        graphics.library
  139. Offset:            -$01E0 (-480)
  140. Modula-2 Module:     Text
  141. Syntax:                AddFont(textFont)
  142. C:                    void AddFont(struct TextFont *)
  143. Machine Language:     AddFont(a1)
  144. Modula-2:        AddFont(textFont: TextFontPtr)
  145. Arguments:        textFont = TextFont structure (in public RAM) to add
  146. Result:            none
  147. -------------------------
  148. AddFreeList
  149. Description:        adds memory to the free list
  150. Library:        icon.library
  151. Offset:            -$0048 (72)
  152. Modula-2 Module:     Icon
  153. Syntax:                status = AddFreeList(free, mem, len)
  154. C:                    long AddFreeList(struct FreeList *, char *, long)
  155. Machine Language:     d0 = AddFreeList(a0, a1, a2)
  156. Modula-2:           AddFreeList(free: FreeListPtr; mem: ADDRESS; len:
  157.             LONGCARD): BOOLEAN
  158. Arguments:        free = FreeList structure
  159.             mem = memory to record
  160.             len = length of the memory to record
  161. Result:            status = nonzero value if the call succeeded
  162. -------------------------
  163. AddGadget
  164. Description:        adds gadget to window
  165. Library:        intuition.library
  166. Offset:            -$002A (-42)
  167. Modula-2 Module:     Intuition
  168. Syntax:                position = AddGadget(window, gadget, position)
  169. C:                    long AddGadget(struct Window *, struct Gadget *, long)
  170. Machine Language:     d0 = AddGadget(a0, a1, d0)
  171. Modula-2:        AddGadget(window: WindowPtr; gadget: GadgetPtr; position:
  172.             INTEGER): INTEGER
  173. Arguments:        window = window to contain gadget
  174.             gadget = gadget to add
  175.             position = position in gadget list for new gadget; -1 for end of
  176.             list
  177. Result:            position = position where gadget is actually added
  178. -------------------------
  179. AddGList
  180. Description:        adds or inserts a gadget list to an existing gadget list
  181. Library:        intuition.library
  182. Offset:            -$01B6 (-438)
  183. Modula-2 Module:     Intuition
  184. Syntax:             position = AddGList(window, gadget, position, numGadgets, 
  185.             requester)
  186. C:                long AddGList(struct Window *, Gadget *, long, long, struct
  187.             Requester *)
  188. Machine Language:     d0 = AddGList(a0, a1, d0, d1, a2)
  189. Modula-2:        AddGList(window: WindowPtr; gadget: GadgetPtr; position:
  190.             INTEGER; numGadgets: INTEGER; requester: RequesterPtr):
  191.             CARDINAL
  192.  
  193. Arguments:        window = window to receive gadgets
  194.             gadget = first gadget in new gadget list
  195.             position = position in existing gadget list where new gadget list
  196.             should be added
  197.             numGadgets = number of gadgets to add
  198.             requester = requester to receive gadgets; NULL if gadgets are not
  199.             to be part of a requester
  200. Result:            position = position where gadget list is actually added
  201. -------------------------  
  202. AddHead
  203. Description:           inserts a node at the head of a list
  204. Library:            exec.library
  205. Offset:             -$00F0 (-240)
  206. Modula-2 Module:     Lists
  207. Syntax:                AddHead(list, node)
  208. C:                    void AddHead(struct List *, struct Node *)
  209. Machine Language:    AddHead(a0, a1)
  210. Modula-2:        AddHead(list: ListPtr; VAR node: NodePtr)
  211. Arguments:        list = list header
  212.             node = node to insert
  213. Result:            none
  214. -------------------------
  215. AddIntServer
  216. Description:        adds an interrupt server to the system
  217. Library:        exec.library
  218. Offset:            -$00A8 (-168)
  219. Modula-2 Module:     Interrupts
  220. Syntax:                AddlntServer(intNum, interrupt)
  221. C:                    void AddIntServer(long, struct Interrupt *)
  222. Machine Language:     AddIntServer(d0, a1)
  223. Modula-2:        AddIntServer(intNum: CARDINAL; interrupt: InterruptPtr)
  224. Arguments:        intNum = portia interrupt bit (0-4)
  225.             interrupt = interrupt server node
  226. Result:            none
  227. ------------------------
  228. AddLibrary
  229. Description:        adds a library to the system
  230. Library:        exec.library
  231. Offset:            -$018C (-396)
  232. Modula-2 Module:     Libraries
  233. Syntax:               AddLibrary(library)
  234. C:                    void AddLibrary(struct Library *)
  235. Machine Language:     AddLibrary(a1)
  236. Modula-2:           AddLibrary(library:LibraryPtr)
  237. Arguments:          library = initialized Library structure
  238. Result:            none
  239. -------------------------
  240. AddMemList
  241. Description:        adds memory to the system's pool of free memory
  242. Library:            exec.library
  243. Offset:             -$026A (-618)
  244. Modula-2 Module:     Memory
  245. Syntax:                AddMemList(size, attributes, pri, base, name)
  246. C:                    void AddMemList(long, long, long, char *, char *)
  247. Machine Language:     AddMemList(d0, d1, d2, a0, a1)
  248. Modula-2:        AddMemList(size: LONGCARD; attributes: MemReqSet; pri:
  249.             INTEGER; base: ADDRESS; name: STRPTR)
  250. Arguments:        size = size of memory block in bytes
  251.             attributes = type of memory-MEMF_PUBLIC, MEMF_CHIP,
  252.             MEMF_FAST, MEMB_CLEAR
  253.             pri = priority of memory-CHIP memory has a priority of -10;
  254.             16-bit expansion memory has a priority of 0
  255.             base = address of the first location in the memory block
  256.             name = name to be used in memory header; NULL for no name
  257. Result:            none
  258. -------------------------
  259. AddPort
  260. Description:        adds a message port to the system
  261. Library:        exec.library
  262. Offset:            -$0162 (-354)
  263. Modula-2 Module:     Ports
  264. Syntax:                AddPort(port)
  265. C:                    void AddPort(struct MsgPort *)
  266. Machine Language:     AddPort(a1)
  267. Modula-2:        AddPort(port: MsgPortPtr)
  268. Arguments:        port = message port to add
  269. Result:            none
  270. -------------------------
  271. AddResouree
  272. Description:        adds a resource to the system
  273. Library:        exec.library
  274. Offset:            -$01E6 (-486)
  275. Modula-2 Module:     Resources
  276. Syntax:                AddResource(resource)
  277. C:                    void AddResource(struct Resource *)
  278. Machine Language:     AddResource(a1)
  279. Modula-2:        AddResource(resource: ResourcePtr)
  280. Arguments:        resource = resource node
  281. Result:            none
  282. -------------------------
  283. AddSemaphore
  284. Description:        attaches a signal semaphore to the system
  285. Library:        exec.library
  286. Offset:            -$0258 (-600)
  287. Modula-2 Module:     Semaphores
  288. Syntax:                AddSemaphore(signalSemaphore)
  289. C:                    void AddSemaphore(struct SignalSemaphore *)
  290. Machine Language:     AddSemaphore(a1)
  291. Modula-2:        AddSemaphore(signalSemaphore: SignalSemaphorePtr)
  292. Arguments:        signalSemaphore = initialized SignalSemaphore structure
  293. Result:            none
  294. -------------------------
  295. AddTail
  296. Description:        appends a node to the tail of a list
  297. Library:        exec.library
  298. Offset:            -$00F6 (-246)
  299. Modula-2 Module:     Lists
  300. Syntax:                AddTail(list, node)
  301. C:                    void AddTail(struct List *, struct Node *)
  302. Machine Language:     AddTail(a0, a1)
  303. Modula-2:        AddTail(list: ListPtr; node: NodePtr)
  304. Arguments:        list = list header
  305.             node = node to insert
  306. Result:            none
  307. -------------------------
  308. AddTask
  309. Description:        adds a task to the system
  310. Library:        exec.library
  311. Offset:            -$011A (-282)
  312. Modula-2 Module:     Tasks
  313. Syntax:                AddTask(task, initialPC, finalPC)
  314. C:                    void AddTask(struct Task *, char *, char *)
  315. Machine Language:     AddTask(a1, a2, a3)
  316. Modula-2:        AddTask(task: TaskPtr; initialPC, finalPC:ADDRESS)
  317. Arguments:        task = task control block
  318.             initialPC = initial entry point
  319.             finalPC = address of entry point of finalization code
  320. Result:            none
  321. -------------------------
  322. AddTOF
  323. Description:        adds a task to the TopOfFrame (vertical-blanking interval) inter-
  324.             rupt server chain
  325. Library:        amiga.lib (linked library)
  326. Modula-2 Module:     none
  327. Syntax:               AddTOF(i, p, a)
  328. C:                    void AddTOF(struct Isrvstr *, APTR, APTR)
  329. Machine Language:     pea a
  330.             pea p
  331.             pea i
  332.             jsr _AddTOF
  333.             add.l #12,sp
  334. Modula-2:        not available
  335. Arguments:        i = Isrvstr structure
  336.             p = entry point of routine to call at every vertical blank
  337.             a = array of long words that will receive routine's arguments
  338. Result:            none
  339. -------------------------
  340. AddVSprite
  341. Description:        adds VSprite to GEL list
  342. Library:        graphics.library
  343. Offset:            -$0066 (-102)
  344. Modula-2 Module:     Gels
  345. Syntax:               AddVSprite(vSprite, rastPort)
  346. C:                    void AddVSprite(struct VSprite *, struct RastPort *)
  347. Machine Language:     AddVSprite(a0, a1)
  348. Modula-2:              AddVSprite(vSprite: VSpritePtr; rastPort: RastPortPtr)
  349. Arguments:             vSprite = initialized VSprite structure
  350.             rastPort = RastPort structure
  351. Result:            none
  352. -------------------------   
  353. afp
  354. Description:         converts an ASCII string into a fast floating point number
  355. Library:            amiga.lib (linked library)
  356. Modula-2 Module:     none
  357. Syntax:                fnum = afp(string)
  358. C:                   float afp(char *)
  359. Machine Language:     pea string
  360.             jsr _afp ;fnum returned in d0/d1
  361.             addq.l #4,sp
  362. Modula-2:        not available; use ConvStrToReal in RealConversions module
  363. Arguments:        string = string to convert
  364. Result:            fnum = floating point equivalent of string arguments
  365. -------------------------
  366. Alert
  367. Description:        alerts the user of a serious error
  368. Library:        exec.library
  369. Offset:            -$006C (-108)
  370. Modula-2 Module:     Alerts
  371. Syntax:                Alert(alertNum, flags)
  372. C:                    void Alert(long, char *)
  373. Machine Language:     Alert(d7, a5)
  374. Modula-2:        Alert(alertNum: LONGCARD; flags: LONGCARD)
  375. Arguments:        alertNum = alert number
  376.             flags = second part of Guru Meditation number (usually the ad-
  377.             dress of the offending task)
  378. Result:            none
  379. -------------------------
  380. AllocAbs
  381. Description:        allocates a block of memory from a specified location
  382. Library:        exec.library
  383. Offset:            -$00CC (-204)
  384. Modula-2 Module:     Memory
  385. Syntax:                memoryBlock = AllocAbs(byteSize, location)
  386. C:                    void *AllocAbs(long, void *)
  387. Machine Language:     d0 = AllocAbs(d0, a1)
  388. Modula-2:             AllocAbs(byteSize: LONGCARD; location: ADDRESS): ADDRESS
  389. Arguments:             byteSize = size of desired block in bytes
  390.             location = address where the memory must be
  391. Result:            memoryBlock = pointer to allocated block; NULL if unsuccessful
  392. ------------------------- 
  393. Allocate
  394. Description:        allocates a block of memory
  395. Library:            exec.library
  396. Offset:             -$00BA (-186)
  397. Modula-2 Module:     Memory
  398. Syntax:                memoryBlock = Allocate(freeList, byteSize)
  399. C:                    void *Allocate(struct MemHeader *, long)
  400. Machine Language:     d0 = Allocate(a0, d0)
  401. Modula-2:        Allocate(freeList: MemHeaderPtr; byteSize: LONGCARD):
  402.             ADDRESS
  403. Arguments:        freeList = memory list header
  404.             byteSize = size of desired block in bytes
  405. Result:            memoryBlock = pointer to allocated block; NULL if unsuccessful.
  406. -------------------------
  407. AllocBoardMem
  408. Description:        allocates expansion board memory
  409. Library:        expansion.library
  410. Offset:            -$002A (-42)
  411. Modula-2 Module:     Expansion
  412. Syntax:                startSlot = AllocBoardMem(slotSpec)
  413. C:                   long AllocBoardMem(long)
  414. Machine Language:     d0 = AllocBoardMem(d0)
  415. Modula-2:        AllocBoardMem(slotSpec: INTEGER): INTEGER
  416. Arguments:        slotSpec = number of slots to allocate
  417. Result:            startSlot = slot allocated; -1 if unsuccessful
  418. ------------------------
  419. AllocCList
  420. Description:        allocates and initializes a clist
  421. Library:        clist.library
  422. Offset:            $0024 (-36)
  423. Modula-2 Module:     none
  424. Syntax:                cList = AllocCList(cLPool)
  425. C:                    long AllocCList(long)
  426. Machine Language:     d0 = AllocCList(a1)
  427. Modula-2:              not available
  428. Arguments:             cLPool = initialized CListPool
  429. Result:            cList = longword cList descriptor; negative if unsuccessful.
  430. ------------------------- 
  431. AllocConfigDev
  432. Description:          allocates a ConfigDev structure
  433. Library:            expansion.library
  434. Offset:             -$0030 (-48)
  435. Modula-2 Module:     ConfigVars
  436. Syntax:                configDev = AllocConfigDev( )
  437. C:                    struct ConfigDev *AllocConfigDev(void)
  438. Machine Language:     d0 = AllocConfigDev( )
  439. Modula-2:        AllocConfigDev( ): ConfigDevPtr
  440. Arguments:        none
  441. Result:            configDef = a valid ConfigDev structure; NULL if unsuccessful
  442. -------------------------
  443. AllocEntry
  444. Description:        allocates many regions of memory
  445. Library:        exec.library
  446. Offset:            -$00DE (-222)
  447. Modula-2 Module:     Memory
  448. Syntax:                memlist = AllocEntry(memlist)
  449. C:                    struct MemList *AllocEntry(stuct MemList *)
  450. Machine Language:     d0 = AllocEntry(a0)
  451. Modula-2:           AllocEntry(memList: MemListPtr): MemListPtr
  452. Arguments:          memList = initialized cList pool
  453. Result:             memList = different memList filled with allocated memory
  454. ------------------------
  455. AllocExpansionMem
  456. Description:         allocates expansion memory
  457. Library:            expansion.library
  458. Offset:             -$0036 (-54)
  459. Modula-2 Module:     Expansion
  460. Syntax:                startSlot = AllocExpansionMem(numSlots, slotOffset)
  461. C:                    CPTR AllocExpansionMem(long, long)
  462. Machine Language:     d0 = AllocExpansionMem(d0, d1)
  463. Modula-2:              AllocExpansionMem(numSlots, slot Offset: INTEGER): INTEGER
  464. Arguments:             numSlots = number slots to allocate
  465.             slotOffset = boundary offset
  466. Result:            startSlot = slot allocated; -1 if unsuccessful
  467. ------------------------- 
  468. AllocMem
  469. Description:        allocates many regions of memory
  470. Library:            exec.library
  471. Offset:             -$00C6 (-198)
  472. Modula-2 Module:     Memory
  473. Syntax:                memoryBlock = AllocMem(byteSize, requirements)
  474. C:                    void *AllocMem(long, long)
  475. Machine Language:     d0 = AllocMem(d0, d1)
  476. Modula-2:        AllocMem(byteSize: LONGCARD; requirements: MemReqSet):
  477.             ADDRESS
  478. Arguments:        byteSize = size of desired block in bytes
  479.             requirements = type of memory-MEMF_PUBLIC,
  480.             MEMF_CHIP, MEMF_FAST, MEMB_CLEAR
  481. Result:            memoryBlock = pointer to allocated block
  482. -------------------------
  483. AllocRaster
  484. Description:        allocates space for a bit plane
  485. Library:        graphics.library
  486. Offset:            -$01EC (-492)
  487. Modula-2 Module:     Rasters
  488. Syntax:                raster = AllocRaster(width, height)
  489. C:                    PLANEPTR AllocRaster(long, long)
  490. Machine Language:     d0 = AllocRaster(d0, d1)
  491. Modula-2:        AllocRaster(width, height: CARDINAL): PlanePtr
  492. Arguments:        width = width of bitplane in pixels
  493.             height = height of bitplane in pixels
  494. Result:            raster = pointer to allocated memory; NULL if unsuccessful
  495. -------------------------
  496. AllocRemember
  497. Description:        calls AllocMem and creates a link node
  498. Library:        intuition.library
  499. Offset:            -$018C (-396)
  500. Modula-2 Module:     Intuition
  501. Syntax:                memoryBlock = AllocRemember(rememberKey, size, flags)
  502. C:                    char *AllocRemember(struct Remember *, long, long)
  503. Machine Language:     d0 = AllocRemember(a0, d0, d1)
  504. Modula-2:              AllocRemember(VAR rememberKey: RememberPrt; size:
  505.             LONGCARD; flags: MemReqSet): ADDRESS
  506. Arguments:        rememberKey = address of pointer to Remember structure
  507.             size = size of desired block in bytes
  508.              flags = type of memory-MEMF_PUBLIC, MEMF_CHIP, 
  509.             MEMF_FAST, MEMB_CLEAR
  510. Result:            memoryBlock = pointer to allocated block
  511. -------------------------
  512. AllocSignal
  513. Description:        allocates a signal bit
  514. Library:        exec.library
  515. Offset:            -$014A (-330)
  516. Modula-2 Module:     Tasks
  517. Syntax:                signalNum = AllocSignal(signalNum)
  518. C:                    long AllocSignal(long)
  519. Machine Language:     d0 = AllocSignal(d0)
  520. Modula-2:        AllocSignal(signalNum: SIGNAL): SIGNAL
  521. Arguments:        signalNum = desired signal number (0-31); -1 for no preference
  522. Result:            signalNum = signal number allocated; -1 if no signal is
  523.             available
  524. -------------------------
  525. AllocTrap
  526. Description:        allocates a processor trap vector
  527. Library:        exec.library
  528. Offset:            -$0156 (-342)
  529. Modula-2 Module:     Tasks
  530. Syntax:                trapNum = AllocTrap(trapNum)
  531. C:                    long AllocTrap(long)
  532. Machine Language:     d0 = AllocTrap(d0)
  533. Modula-2:        AllocTrap(trapNum: TRAP): TRAP
  534. Arguments:        trapNum = desired trap number (0-15); -1 for no preference
  535. Result:            trapNum = trap number allocated; -1 if no trap is available
  536. -------------------------
  537. AllocWBObject
  538. Description:        allocates a Workbench object
  539. Library:        icon.library
  540. Offset:            -$0042 (-66)
  541. Modula-2 Module:     none
  542. Syntax:                object = AllocWBObject( )
  543. C:                    struct WBObject AllocWBObject(void)
  544. Machine Language:     d0 = AllocWBObject( )
  545. Modula-2:           not available
  546. Arguments:          none
  547. Result:            object = the WBObject; NULL if unsuccessful
  548. -------------------------
  549. AndRectRegion
  550. Description:        performs a two-dimensional AND operation of a rectangle with a
  551.             region, leaving the result in the region
  552. Library:        graphics.library
  553. Offset:            -$01F8 (-504)
  554. Modula-2 Module:     Regions
  555. Syntax:                AndRectRegion(region, rectangle)
  556. C:                    void AndRectRegion(struct Region *, struct Rectangle *)
  557. Machine Language:     AndRectRegion(a0, a1)
  558. Modula-2:        AndRectRegion(region: RegionPtr; rectangle: RectanglePtr)
  559. Arguments:        region = Region structure
  560.             rectangle = Rectangle structure
  561. Result:            none
  562. -------------------------
  563. AndRegionRegion
  564. Description:        performs a two-dimensional AND operation of one region with a
  565.             second region, leaving the result in second region
  566. Library:        graphics.library
  567. Offset:            -$0270 (-624)
  568. Modula-2 Module:     Regions
  569. Syntax:                success = AndRegionRegion(region1, region2)
  570. C:                    long AndRegionRegion(struct Region *, struct Region *)
  571. Machine Language:     d0 = AndRegionRegion(a0, a1)
  572. Modula-2:        AndRegionRegion(region1, region2: RegionPtr): BOOLEAN
  573. Arguments:        region1 = Region structure
  574.             region2 = Region structure
  575. Result:    success =     TRUE if successful; FALSE if unsuccessful
  576. -------------------------
  577. Animate
  578. Description:        processes every AnimOb in the current animation list
  579. Library:        graphics.library
  580. Offset:            -$00A2 (-162)
  581. Modula-2 Module:     Gels
  582. Syntax:                Animate(anKey, rastPort)
  583. C:                    void Animate(long, struct RastPort *)
  584. Machine Language:     Animate(a0, a1)
  585. Modula-2:           Animate(ankey: ADDRESS; rastPort: RastPortPtr)
  586. Arguments:             anKey = address of variable that points to the head AnimOb
  587.             rastPort = RastPort structure
  588. Result:            none
  589. -------------------------
  590. AreaCircle (macro)
  591. Description:         adds a circle to the list of points used to fill an area
  592. C Include File:     include/graphics/gfxmacros.h
  593. ML Include File:     none
  594. Modula-2 Module:     Areas
  595. Syntax:                error = AreaCircle(rastPort, cx, cy, radius)
  596. C:                    long AreaCircle(struct RastPort *, long, long, long)
  597. Machine Language:     not available, use AreaEllipse
  598. Modula-2:        AreaCircle(rp: RastPortPtr; cx, cy, radius: INTEGER): INTEGER
  599. Arguments:        rastPort = RastPort structure
  600.             cx = horizontal coordinate of circle's center
  601.             cy = vertical coordinate of circle's center
  602.             radius = circle's radius
  603. Result:            error = 0 if successful; -1 if no room left in list of points
  604. -------------------------
  605. AreaDraw
  606. Description:        adds a point to the list of points used to fill an area
  607. Library:        graphics.library
  608. Offset:            -$0102 (-258)
  609. Modula-2 Module:     Areas
  610. Syntax:                error = AreaDraw(rastPort, x, y)
  611. C:                    long AreaDraw(struct RastPort *, long, long)
  612. Machine Language:     d0 = AreaDraw(a1, d0, d1)
  613. Modula-2:        AreaDraw(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
  614. Arguments:        rastPort = RastPort structure
  615.             x = horizontal coordinate of point
  616.             y = vertical coordinate of point
  617. Result:            error = 0 if successful; -1 if no room left in list of points
  618. -------------------------
  619. AreaEllipse
  620. Description:        adds an ellipse to the list of points used to fill an area
  621. Library:        graphics.library
  622. Offset:            -$00BA (-186)
  623. Modula-2 Module:     Areas
  624. Syntax:                error = AreaEllipse(rastPort, cx, cy, a, b)
  625. C:                    long AreaEllipse(struct RastPort *, long, long, long, long)
  626. Machine Language:     d0 = AreaEllipse(a1, d0, d1, d2, d3)
  627. Modula-2:           AreaEllipse(rastPort: RastPortPtr; cx, cy, a, b: INTEGER):
  628.             INTEGER
  629. -------------------------
  630. AttemptLockLayerRom
  631. Description:        attempts to lock a Layer structure
  632. Library:            graphics.library
  633. Offset:             -$028E (-582)
  634. Modula-2 Module:     Clip
  635. Syntax:                success = AttemptLockLayerRom(layer)
  636. C:                    long AttemptLockLayerRom(struct Layer *)
  637. Machine Language:     d0 = AttemptLockLayerRom(a5)
  638. Modula-2:        AttemptLockLayerRom(layer: LayerPtr): BOOLEAN
  639. Arguments:        layer = Layer structure to lock
  640. Result:            success = TRUE if successful; FALSE if unsuccessful
  641. -------------------------
  642. AttemptSemaphore
  643. Description:        attempts to obtain access to a SignalSemaphore structure
  644. Library:        exec.library
  645. Offset:            -$0240 (-576)
  646. Modula-2 Module:     Semaphores
  647. Syntax:                success = AttemptSemaphore(signalSemaphore)
  648. C:                    long AttemptSemaphore(struct SignalSemaphore *)
  649. Machine Language:     d0 = AttemptSemaphore(a0)
  650. Modula-2:        AttemptSemaphore(signalSemaphore: SignalSemaphorePtr):
  651.             BOOLEAN
  652. Arguments:        signalSemaphore = initialized SignalSemaphore structure
  653. Result:            success = TRUE if successful; FALSE if another task is using
  654.             specified SignalSemaphore structure
  655. -------------------------
  656. AutoRequest
  657. Description:        automatically creates and gets a response from a requester
  658. Library:        intuition.library
  659. Offset:            -$015C (-348)
  660. Modula-2 Module:     Intuition
  661. Syntax:                response = AutoRequest(window, bodyText, positiveText,
  662.             negativeText, positiveFlags, negativeFlags, width, height)
  663. C:                    long AutoRequest(struct Window *, struct IntuiText *, struct
  664.             IntuiText *, struct IntuiText *, long, long, long)
  665. Machine Language:     d0 = AutoRequest(a0, a1, a2, a3, d0, d1, d2, d3)
  666. Modula-2:              AutoRequest(window: WindowPtr; bodyText, positiveText,
  667.             negativeText: IntuiTextPtr; positiveFlags, negativeFlags:
  668.             IDCMPFlagsSet; width, height: INTEGER): BOOLEAN
  669. Arguments:        window = Window structure
  670.             bodyText = IntuiText structure
  671.             positiveText = IntuiText structure
  672.             negativeText = IntuiText structure
  673.             positiveFlags = flags for the IDCMP
  674.             negativeFlags = flags for the IDCMP
  675.             width = width of requester
  676.             height = height of requester
  677. Result:            response = TRUE for a positive response; FALSE for a negative
  678.             response
  679. -------------------------
  680. AvailFonts
  681. Description:        builds an array of all available fonts on disk and/or in memory
  682. Library:        diskfont.library
  683. Offset:            -$0024 (-36)
  684. Modula-2 Module:     DiskFont
  685. Syntax:                error = AvailFonts(buffer, bufBytes, types)
  686. C:                    long AvailFonts(char *, long, long)
  687. Machine Language:     d0 = AvailFonts(a0, d0, d1)
  688. Modula-2:        AvailFonts(buffer: ADDRESS; bufBytes: LONGCARD; types:
  689.             AFTypeSet): LONGCARD
  690. Arguments:        buffer = memory buffer used to hold the array
  691.             bufBytes = size of buffer in bytes
  692.             types = type of fonts to search for-AFF_MEMORY and/or
  693.             AFF_DISK
  694. Result:            error = 0 if successful, otherwise, error contains the number of
  695.             additional bytes that must be added to the buffer size (bufBytes)
  696.             to contain all of the font information
  697. -------------------------
  698. AvailMem
  699. Description:        returns memory available given certain requirements
  700. Library:        exec.library
  701. Offset:            -$00D8 (-216)
  702. Modula-2 Module:     Memory
  703. Syntax:                size = AvailMem(requirements)
  704. C:                    long AvailMem(long)
  705. Machine Language:     d0 = AvailMem(d1)
  706. Modula-2:              AvailMem(requirements: MemReqSet): LONGCARD
  707. Arguments:             requirements = type of memory required-MEMF_PUBLIC,
  708.             MEMF_CHIP, MEMF_FAST, MEMB_CLEAR
  709. Result:            size = total free space remaining
  710. ------------------------- MISSING IN ORIGINAL TEXT!!!! -------------------------
  711. Arguments:        rastPort = RastPort structure
  712.             cx = horizontal coordinate of ellipse's center
  713.             cy = vertical coordinate of ellipse's center
  714.             a = horizontal radius of ellipse (must be greater than O)
  715.             b = vertical radius of ellipse (must be greater than O)
  716. Result:            error = 0 if successful; -1 if no room left in list of points
  717. -------------------------
  718. AreaEnd
  719. Description:        fills an area using a list of vertices
  720. Library:        graphics.library
  721. Offset:            -$0108 (-264)
  722. Modula-2 Module:     Areas
  723. Syntax:                error = AreaEnd(rastPort)
  724. C:                    long AreaEnd(struct RastPort *)
  725. Machine Language:     d0 = AreaEnd(a1)
  726. Modula-2:        AreaEnd(rastPort: RastPortPtr): INTEGER
  727. Arguments:        rastPort = RastPort structure
  728. Result:            error = 0 if successful; -1 if unsuccessful
  729. -------------------------
  730. AreaMove
  731. Description:        closes the current polygon described by a table of vertices and de-
  732.             fines the starting point for a new polygon
  733. Library:        graphics.library
  734. Offset:            -$00FC (-252)
  735. Modula-2 Module:     Areas
  736. Syntax:                error = AreaMove(rastPort, x, y)
  737. C:                    long AreaMove(struct RastPort *, long, long)
  738. Machine Language:     d0 = AreaMove(a1, d0, d1)
  739. Modula-2:        AreaMove(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
  740. Arguments:        rastPort = RastPort structure
  741.             x = horizontal coordinate of point
  742.             y = vertical coordinate of point
  743. Result:            error = 0 if successful; -1 if no room left in list of points
  744. -------------------------
  745. arnd
  746. Description:        rounds a floating point number contained in an ASCII string
  747. Library:        amiga.lib (linked library)
  748. Modula-2 Module:     none
  749. Syntax:                arnd(place, exp, string)
  750. C:            void arnd(long, long, char *)
  751. Machine Language:     pea string 
  752.             move.l #exp,-(sp) 
  753.             move.l #place,-(sp) 
  754.             jsr _arnd         ;string contents are modified 
  755.             add.l #12,sp
  756. Modula-2:        not available
  757. Arguments:        place = number of desired decimal places
  758.             exp = exponent value of number in string argument
  759.             string = string containing number to round
  760. Result:            string argument is modified to contain rounded number
  761. -------------------------
  762. AskFont
  763. Description:        puts text attributes of the current font in the specified TextAttr
  764.             structure
  765. Library:        graphics.library
  766. Offset:            -$01DA (-474)
  767. Modula-2 Module:     Text
  768. Syntax:                AskFont(rastPort, textAttr)
  769. C:                    void AskFont(struct RastPort *, struct TextAttr *)
  770. Machine Language:     AskFont(a1, a0)
  771. Modula-2:        AskFont(rastPort: RastPortPtr; textAttr: TextAttrPtr)
  772. Arguments:        rastPort = RastPort structure
  773.             textAttr = TextAttr structure to be filled
  774. Result:            returns results in textAttr argument
  775. -------------------------
  776. AskSoftStyle
  777. Description:        returns the soft style bits of the current font
  778. Library:        graphics.library
  779. Offset:            -$0054 (-84)
  780. Modula-2 Module:     Text
  781. Syntax:                enable = AskSoftStyle(rastPort)
  782. C:                    long AskSoftStyle(struct RastPort *)
  783. Machine Language:     d0 = AskSoftStyle(a1)
  784. Modula-2:              AskSoftStyle(rastPort: RastPortPtr): FontStyleSet
  785. Arguments:             rastPort = RastPort structure
  786. Result:            enable = valid style bits
  787. -------------------------
  788. BeginIO 
  789. Description:         initiates an IO request like SendIO( ), but does not clear io_Flags 
  790.             field 
  791. Library:            amiga.lib (linked library) 
  792. Modula-2 Module:     IO 
  793. Syntax:                BeginIO(ioRequest) 
  794. C:                    void BeginIO(struct IORequest *) 
  795. Machine Language:     pea ioRequest
  796.             jsr _BeginIO
  797.             addq.l #4,sp
  798. Modula-2:        BeginIO(ioRequest: ADDRESS)
  799. Arguments:        IORequest = initialized IORequest structure
  800. Result:            none
  801. -------------------------
  802. BeginRefresh
  803. Description:        sets up a window for optimized refreshing
  804. Library:        intuition.library
  805. Offset:            -$0162 (-354)
  806. Modula-2 Module:     Intuition
  807. Syntax:                BeginRefresh(window)
  808. C:                    void BeginRefresh(struct Window *)
  809. Machine Language:     BeginRefresh(a0)
  810. Modula-2:        BeginRefresh(window: WindowPtr)
  811. Arguments:        window = window that needs updating
  812. Result:            none
  813. -------------------------
  814. BeginUpdate
  815. Description:        prepares to repair a damaged layer
  816. Library:        layers.library
  817. Offset:            -$004E (-78)
  818. Modula-2 Module:     Layers
  819. Syntax:                success = BeginUpdate(layer)
  820. C:                    long BeginUpdate(struct Layer *)
  821. Machine Language:     d0 = BeginUpdate(a0)
  822. Modula-2:              BeginUpdate(layer: LayerPtr): BOOLEAN
  823. Arguments:             layer = Layer to be repaired
  824. Result:            TRUE if successful; FALSE if unsuccessful
  825. ------------------------- 
  826. BehindLayer
  827. Description:         moves a layer behind other layers
  828. Library:            layers.library
  829. Offset:             -$0036 (-54)
  830. Modula-2 Module:     Layers
  831. Syntax:               success = BehindLayer(dummy, layer)
  832. C:                    long BehindLayer(struct Layer_Info, struct Layer *)
  833. Machine Language:     d0 = BehindLayer(a0, a1)
  834. Modula-2:        BehindLayer(layer: LayerPtr): BOOLEAN
  835. Arguments:        dummy = unused
  836.             layer = Layer to move behind other layers
  837. Result:            success = TRUE if successful; FALSE if unsuccessful
  838. -------------------------
  839. BltBitMap
  840. Description:        uses the blitter chip to move (blit) a rectangular region of bits from
  841.             a BitMap to a BitMap
  842. Library:        graphics.library
  843. Offset:            -$001E (-30)
  844. Modula-2 Module:     Blitter
  845. Syntax:           planes = BltBitMap(scrBitMap, srcX, srcY, destBitMap, destX, 
  846.             destY, sizeX, sizeY, miniterm, mask, tempA)
  847.  
  848. C:                long BltBitMap(struct BitMap *, long, long, struct BitMap *, long, 
  849.             long, long, long, long, long, char *)
  850. Machine Language:     d0 = BltBitMap(a0, d0, d1, a1, d2, d3, d4, d5, d6, d7, a2)
  851. Modula-2:        BltBitMap(scrBitMap: BitMapPtr; srcX, srcY: INTEGER;
  852.             destBitMap: BitMapPtr; destX, destY: INTEGER; sizeX, sizeY:
  853.             INTEGER; miniterm: BYTE; mask: BITSET; tempA: ADDRESS):
  854.             LONGCARD
  855. Arguments:        scrBitMap = source BitMap structure
  856.             srcX = horizontal coordinate of upper left corner of source
  857.             rectangle
  858.             srcY = vertical coordinate of upper left corner of source rectangle
  859.             destBitMap = destination BitMap structure
  860.             destX = horizontal coordinate of upper left corner of destination
  861.             rectangle
  862.             destY = vertical coordinate of upper left corner of destination
  863.             rectangle
  864.             sizeX = width of rectangle
  865.             sizeY = height of rectangle
  866.             miniterm = logic function to apply to rectangle
  867.             mask = bit planes to be affected
  868.             tempA = pointer to chip memory for one source line or NULL
  869. Result:            planes = actual number of planes involved in blit
  870. -------------------------
  871. BltBltMapRastPort
  872. Description:        moves a rectangular region from a BitMap to a RastPort
  873. Library:         graphics.library
  874. Offset:             -$025E (-606)
  875. Modula-2 Module:    Blitter
  876. Syntax:                BltBitMapRastPort(srcBitMap, srcX, srcY, destRastPort, destX, 
  877.             destY, sizeX, sizeY, miniterm)
  878. C:                void BltBitMapRastPort(struct BitMap *, long, long, struct RastPort
  879.             *, long, long, long, long, long)
  880. Machine Language:     BltBitMapRastPort(a0, d0, d1, a1, d2, d3, d4, d5, d6)
  881. Modula-2:        BltBitMapRastPort(srcBitMap: BitMapPtr; srcX, srcY: INTEGER;
  882.             destRastPort: RastPortPtr; destX, destY: INTEGER; sizeX, sizeY:
  883.             INTEGER; miniterm: BYTE)
  884. Arguments:        srcBitMap = source BitMap structure
  885.             srcX = horizontal coordinate of upper left corner of source
  886.             rectangle
  887.             srcY = vertical coordinate of upper left corner of source rectangle
  888.             destRastPort = destination RastPort structure
  889.             destX = horizontal coordinate of upper left corner of destination
  890.             rectangle
  891.             destY = vertical coordinate of upper left corner of destination
  892.             rectangle
  893.             sizeX = width of rectangle
  894.             sizeY = height of rectangle
  895.             miniterm = logic function to apply to rectangle
  896. Result:            none
  897. -------------------------
  898. BltClear
  899. Description:        fills a section of chip memory with zeros
  900. Library:        graphics.library
  901. Offset:            -$012C (-300)
  902. Modula-2 Module:     Blitter
  903. Syntax:                BltClear(memBlock, byteCount, flags)
  904. C:                    void BltClear(char *, long, long)
  905. Machine Language:     BltClear(a1, d0, d1)
  906. Modula-2:              BltClear(memBlock: ADDRESS; byteCount: LONGCARD; flags:
  907.             BltClearFlagSet)
  908.  
  909. Arguments:        memBlock = memory to clear (must start on a word boundary)
  910.             byteCount = number of bytes to clear
  911.             flags = set bit 0 to force function to wait until memory is cleared;
  912.             set bit 1 if byteCount is to be interpreted as the number of rows
  913.             and bytes per row to clear; clear bit 1 if byteCount is to be inter-
  914.             preted as an even number of bytes
  915. Result:            none
  916. -------------------------
  917. BltMaskBitMapRastPort
  918. Description:         moves a rectangular region from a BitMap to a RastPort through a 
  919.             mask
  920. Library:            graphics.library
  921. Offset:             -$027C (-636)
  922. Modula-2 Module:     Blitter
  923. Syntax:                BltMaskBitMapRastPort(srcBitMap, srcX, srcY, destRastPort, destX, 
  924.             destY, sizeX, sizeY, miniterm, mask)
  925. C:                void BltMaskBitMapRastPort(struct BitMap *, long, long, struct 
  926.             RastPort *, long, long, long, long, long, APTR)
  927. Machine Language:     BltMaskBitMapRastPort(a0, d0, d1, a1, d2, d3, d4, d5, d6, a2)
  928. Modula-2:        BltMaskBitMapRastPort(srcBitMap: BitMapPtr; srcX, srcY: INTE-
  929.             GER; destRastPort: RastPortPtr; destX, destY: INTEGER; sizeX,
  930.             sizeY: INTEGER; miniterm: BYTE; mask: PlanePtr)
  931. Arguments:        srcBitMap = source BitMap structure
  932.             srcX = horizontal coordinate of upper left corner of source
  933.             rectangle
  934.             srcY = vertical coordinate of upper left corner of source rectangle
  935.             destRastPort = destination RastPort structure
  936.             destX = horizontal coordinate of upper left corner of destination
  937.             rectangle
  938.             destY = vertical coordinate of upper left corner of destination
  939.             sizeX = width of rectangle
  940.             sizeY = height of rectangle
  941.             miniterm = logic function to apply to rectangle
  942.             mask = pointer to bit-plane mask
  943. Result:            none
  944. -------------------------
  945. BltPattern
  946. Description:        draws through a mask using standard drawing rules
  947. Library:        graphics.library
  948. Offset:            -$0138 (-312)
  949. Modula-2 Module:     Blitter
  950. Syntax:            BltPattern(destRastPort, pattern, x1, y1, x2, y2, width)
  951. C:                void BltPattern(struct RastPort *, struct RastPort *, long, long, 
  952.             long, long, long)
  953. Machine Language:     BltPattern(a1, a0, d0, d1, d2, d3, d4)
  954. Modula-2:        BltPattern(destRastPort: RastPortPtr; pattern: ADDRESS; x1, y1:
  955.             INTEGER; x2, y2: INTEGER; width: INTEGER)
  956. Arguments:        destRastPort = destination RastPort
  957.             pattern = two-dimensional mask pattern
  958.             x1 = horizontal coordinate of upper left corner in destination
  959.             RastPort
  960.             y1 = vertical coordinate of upper left corner in destination
  961.             RastPort
  962.             x2 = horizontal coordinate of lower right corner in destination
  963.             RastPort
  964.             y2 = vertical coordinate of lower right corner in destination
  965.             RastPort
  966.             width = width of mask in bytes
  967. Result:            none
  968. -------------------------
  969. BltTemplate
  970. Description:        "cookie cuts" a shape in a rectangle to a RastPort
  971. Library:        graphics.library
  972. Offset:            -$0024 (-36)
  973. Modula-2 Module:     Blitter
  974. Syntax:                BltTemplate(source, srcX, srcMod, destRastPort, destX, destY, 
  975.             sizeX, sizeY)
  976. C:                void BltTemplate(char *, long, long, struct RastPort *, long, long, 
  977.             long, long)
  978. Machine Language:     BltTemplate(a0, d0, d1, a1, d2, d3, d4, d5)
  979. Modula-2:        BltTemplate(source: PlanePTR; srcX, srcMod: INTEGER;
  980.             destRastPort: RastPortPtr; destX, destY: INTEGER; sizeX, sizeY:
  981.             INTEGER) (changes)
  982. Arguments:        source = template mask
  983.             srcX = horizontal offset into template mask (0-15)
  984.             srcMod = number of bytes per row in template mask
  985.             destRastPort = destination RastPort
  986.             destX = horizontal coordinate of upper left corner in destination
  987.             RastPort
  988.             destY = vertical coordinate of upper left corner in destination
  989.             RastPort
  990.             sizeX = width of rectangular template
  991.             sizeY = height of rectangular template
  992. Result:            none
  993. -------------------------
  994. BNDRYOFF (macro)
  995. Description:        turns boundary mode off
  996. C Include File:     include/graphics/gfxmacros.h
  997. ML Include File:     none
  998. Modula-2 Module:     Pens
  999. Syntax:                BNDRYOFF(rastPort)
  1000. C:                    void BNDRYOFF(struct RastPort *)
  1001. Machine Language:     not available
  1002. Modula-2:        BNDRYOFF(rastPort: RastPortPtr)
  1003. Arguments:        rastPort = RastPort structure
  1004. Result:            none
  1005. -------------------------
  1006. BuildSysRequest
  1007. Description:        builds and displays a system requester
  1008. Library:        intuition.library
  1009. Offset:            -$0168 (-360)
  1010. Modula-2 Module:     Intuition
  1011. Syntax:                window = BuildSysRequest(window, bodyText, positiveText, 
  1012.             negativeText, flags, width, height)
  1013. C:                struct Window *BuildSysRequest(struct Window *, struct IntuiText 
  1014.             *, struct IntuiText *, struct IntuiText *, long, long, long)
  1015. Machine Language:     d0 = BuildSysRequest(a0, a1, a2, a3, d0, d1, d2)
  1016. Modula-2:        BuildSysRequest(window: WindowPtr; bodyText, positiveText,
  1017.             negativeText: IntuiTextPtr; flags: IDCMPFlagsSet; width, height:
  1018.             INTEGER): ADDRESS
  1019. Arguments:        window = Window to contain requester
  1020.             bodyText = IntuiText structure containing requester's main text
  1021.             positiveText = IntuiText structure containing text for positive
  1022.             gadget
  1023.             negativeText = IntuiText structure containing text for negative
  1024.             gadget
  1025.             flags = IDCMP flags for initialization of window containing
  1026.             requester
  1027.             width = requester width
  1028.             height = requester height
  1029. Result:            window = pointer to window containing requester; if requester
  1030.             could not be opened, DisplayAlert( ) is called and this function re-
  1031.             turns TRUE if the left mouse button is pressed and FALSE if the
  1032.             right mouse button is pressed
  1033. ------------------------- 
  1034. BumpRevision
  1035. Description:          creates a new name for the copy of a file, directory, or disk
  1036. Library:               icon.library
  1037. Offset:             -$006C (-108)
  1038. Modula-2 Module:     Icon
  1039. Syntax:                newname = BumpRevision(newbuf, oldname)
  1040. C:                    long BumpRevision(char *, char *)
  1041. Machine Language:     d0 = BumpRevision(a0, a1)
  1042. Modula-2:        BumpRevision(newbuf, oldname: STRPTR)
  1043. Arguments:        newbuf = buffer to contain the new name (must be at least 31
  1044.             characters long)
  1045.             oldname = old name
  1046. Result:            newname = pointer to the new name contained in newbuf
  1047. -------------------------
  1048. Cause
  1049. Description:        causes a software interrupt
  1050. Library:        exec.library
  1051. Offset:            -$00B4 (-180)
  1052. Modula-2 Module:     Interrupts
  1053. Syntax:                Cause(interrupt)
  1054. C:                    void Cause(struct Interrupt *)
  1055. Machine Language:     Cause(a1)
  1056. Modula-2:        Cause(interrupt: InterruptPtr)
  1057. Arguments:        interrupt = initialized interrupt node
  1058. Result:            none
  1059. -------------------------
  1060. CBump
  1061. Description:        moves to the next position in user copper list
  1062. Library:        exec.library
  1063. Offset:            -$016E (-366)
  1064. Modula-2 Module:     Copper
  1065. Syntax:                CBump(copList)
  1066. C:                    void CBump(struct UCopList *)
  1067. Machine Language:     CBump(a1)
  1068. Modula-2:              CBump(copList: UCopListPtr)
  1069. Arguments:             copList = UCopList structure
  1070. Result:            none
  1071. -------------------------
  1072. CEND (macro)
  1073. Description:        adds the final instruction to a user copper list
  1074. C Include File:     include/graphics/gfxmacros.h
  1075. ML Include File:     none
  1076. Modula-2 Module:     Copper
  1077. Syntax:                CEND(copList)
  1078. C:                    void CEND(struct UCopList *)
  1079. Machine Language:     not available
  1080. Modula-2:        CEND(VAR copList: UCopList)
  1081. Arguments:        copList = UCopList structure
  1082. Result:            none
  1083. ------------------------
  1084. ChangeSprite
  1085. Description:        changes the shape of a sprite
  1086. Library:        graphics.library
  1087. Offset:            -$01A4 (-420)
  1088. Modula-2 Module:     Sprites
  1089. Syntax:                ChangeSprite(viewPort, simpleSprite, newdata)
  1090. C:                    void ChangeSprite(struct ViewPort *, struct SimpleSprite *, short *)
  1091. Machine Language:     ChangeSprite(a0, a1, a2)
  1092. Modula-2:        ChangeSprite(viewPort: ViewPortPtr; simpleSprite:
  1093.             SimpleSpritePtr; newdata: ADDRESS)
  1094. Arguments:        viewPort = ViewPort structure
  1095.             simpleSprite = initialized SimpleSprite structure
  1096.             newdata = table of sprite shape data
  1097. Result:            none
  1098. -------------------------
  1099. CheckIO
  1100. Description:        gets the status of an IO request
  1101. Library:        exec.library
  1102. Offset:            -$01D4 (-468)
  1103. Modula-2 Module:     IO
  1104. Syntax:                status = CheckIO(ioRequest)
  1105. C:                    long CheckIO(struct IORequest *)
  1106. Machine Language:     d0 = CheckIO(a1)
  1107. Modula-2:           CheckIO(ioRequest: ADDRESS): ADDRESS
  1108. Arguments:             ioRequest = IORequest block
  1109. Result:             status = NULL if I/O is still in progress; pointer to IORequest
  1110.             block if I/O has completed
  1111. -------------------------
  1112. CINIT (macro)
  1113. Description:         initializes a user copper list
  1114. C Include File:     include/graphics/gfxmacros.h
  1115. ML Include File:     none
  1116. Modula-2 Module:     Copper
  1117. Syntax:                copList = CINIT(copList, num)
  1118. C:                    struct UCopList *CINIT(struct UCopList *, short)
  1119. Machine Language:     not available
  1120. Modula-2:        CINIT(copList: UCopListPtr; num: CARDINAL): UCopListPtr
  1121. Arguments:        copList = UCopList structure
  1122.             num = number of instructions buffer must hold
  1123. Result:            copList = pointer to an initialized UCopList structure, ready to
  1124.             accept copper instructions
  1125. -------------------------
  1126. ClearDMRequest
  1127. Description:        clears the DMRequest of a window
  1128. Library:        intuition.library
  1129. Offset:            -$0030 (-48)
  1130. Modula-2 Module:     Intuition
  1131. Syntax:                success = ClearDMRequest(window)
  1132. C:                    long ClearDMRequest(struct Window *)
  1133. Machine Language:     d0 = ClearDMRequest(a0)
  1134. Modula-2:        ClearDMRequest(window: WindowPtr): BOOLEAN
  1135. Arguments:        window = window from which DMRequest is to be cleared
  1136. Result:            success = TRUE if successful; FALSE if unsuccessful (DMRequest
  1137.             is still in use)
  1138. -------------------------
  1139. ClearEOL
  1140. Description:        clears from the current position to the end of the line
  1141. Library:        graphics.library
  1142. Offset:            -$002A (-42)
  1143. Modula-2 Module:     Text
  1144. Syntax:                ClearEOL(rastPort)
  1145. C:                    void ClearEOL(struct RastPort *)
  1146. Machine Language:     ClearEOL(a1)
  1147. Modula-2:           ClearEOL(rastPort: RastPortPtr)
  1148. Arguments:             rastPort = RastPort structure to clear
  1149. Result:            none
  1150. ------------------------- 
  1151. ClearMenuStrip
  1152. Description:          clears (detaches) a window's menu strip
  1153. Library:            intuition.library
  1154. Offset:             -$0036 (-54)
  1155. Modula-2 Module:     Intuition
  1156. Syntax:                ClearMenuStrip(window)
  1157. C:                    void ClearMenuStrip(struct Window *)
  1158. Machine Language:     ClearMenuStrip(a0)
  1159. Modula-2:        ClearMenuStrip(window: WindowPtr)
  1160. Arguments:        window = Window structure
  1161. Result:            none
  1162. -------------------------
  1163. ClearPointer
  1164. Description:        returns the mouse pointer to its default shape
  1165. Library:        intuition.library
  1166. Offset:            -$003C (-60)
  1167. Modula-2 Module:     Intuition
  1168. Syntax:                ClearPointer(region)
  1169. C:                    void ClearPointer(struct Region *)
  1170. Machine Language:     ClearPointer(a0)
  1171. Modula-2:        ClearPointer(window: WindowPtr)
  1172. Arguments:        window = Window structure
  1173. Result:            none
  1174. -------------------------
  1175. ClearRectRegion
  1176. Description:        performs a two-dimensional clearing operation of a clipping rec
  1177.             tangle with a region, leaving the result in the region
  1178. Library:        graphics.library
  1179. Offset:            -$020A (-522)
  1180. Modula-2 Module:     Regions
  1181. Syntax:                success = ClearRectRegion(region, rectangle)
  1182. C:                    long ClearRectRegion(struct Region *, struct Rectangle *)
  1183. Machine Language:     d0 = ClearRectRegion(a0, a1)
  1184. Modula-2:        ClearRectRegion(region: RegionPtr; rectangle: RectanglePtr):
  1185.             BOOLEAN
  1186. Arguments:        region = Region to clear
  1187.             rectangle = Rectangle to be used as the clipping rectangle
  1188. Result:            success = TRUE if successful; FALSE if unsuccessful
  1189. -------------------------
  1190. ClearRegion
  1191. Description:        removes all rectangles from a region
  1192. Library:            graphics.library
  1193. Offset:             -$0210 (-528)
  1194. Modula-2 Module:     Regions
  1195. Syntax:                ClearRegion(region)
  1196. C:                    void ClearRegion(struct Region *)
  1197. Machine Language:     ClearRegion(a0)
  1198. Modula-2:        ClearRegion(region: RegionPtr)
  1199. Arguments:        region = Region to clear
  1200. Result:            none
  1201. -------------------------
  1202. ClearScreen
  1203. Description:        clears from the current position to the end of the RastPort
  1204. Library:        graphics.library
  1205. Offset:            -$0030 (-48)
  1206. Modula-2 Module:     Text
  1207. Syntax:                ClearScreen(rastPort)
  1208. C:                    void ClearScreen(struct RastPort *)
  1209. Machine Language:     ClearScreen(a1)
  1210. Modula-2:        ClearScreen(rastPort: RastPortPtr)
  1211. Arguments:        rastPort = RastPort to clear
  1212. Result:            none
  1213. -------------------------
  1214. ClipBlit
  1215. Description:        copies bit-map data (and optionally manipulates) from one
  1216.             RastPort to another
  1217. Library:        graphics.library
  1218. Offset:            -$0228 (-552)
  1219. Modula-2 Module:     Blitter
  1220. Syntax:                ClipBlit(scrRastPort, srcX, srcY, destRastPort, destX, destY, sizeX,
  1221.             sizeY, miniterm)
  1222. C:                    void ClipBlit(struct RastPort * long, long, struct RastPort *, long,
  1223.             long, long, long, long)
  1224. Machine Language:     ClipBlit(a0, d0, d1, a1, d2, d3, d4, d5, d6)
  1225. Modula-2:           ClipBlit(scrRPort: RastPortPtr; srcX, srcY: INTEGER; destRPort:
  1226.             RastPortPtr; destX, destY: INTEGER; sizeX, sizeY: INTEGER;
  1227.             miniterm: BYTE)
  1228. Arguments:        scrRastPort = source RastPort structure
  1229.             srcX = horizontal coordinate of upper left corner of source
  1230.             rectangle
  1231.             srcY = vertical coordinate of upper left corner of source rectangle
  1232.             destRastPort = destination RastPort structure
  1233.             destX = horizontal coordinate of upper left corner of destination
  1234.             rectangle
  1235.             destY = vertical coordinate of upper left corner of destination
  1236.             rectangle
  1237.             sizeX = width of rectangle
  1238.             sizeY = height of rectangle
  1239.             miniterm = logic function to apply to rectangle
  1240. Result:            none
  1241. -------------------------
  1242. Close
  1243. Description:        closes an open file
  1244. Library:        dos.library
  1245. Offset:            -$0024 (-36)
  1246. Modula-2 Module:     DOS
  1247. Syntax:                Close(file)
  1248. C:                    void Close(BPTR)
  1249. Machine Language:     Close(d1)
  1250. Modula-2:        Close(file: FileHandle)
  1251. Arguments:        file = BCPL pointer to file handle of file to close
  1252. Result:            none
  1253. -------------------------
  1254. CloseDevice
  1255. Description:        terminates access to a device
  1256. Library:        exec.library
  1257. Offset:            -$01C2 (-450)
  1258. Modula-2 Module:     Devices
  1259. Syntax:                CloseDevice(ioRequest)
  1260. C:                    void CloseDevice(struct IORequest *)
  1261. Machine Language:     CloseDevice(a1)
  1262. Modula-2:           CloseDevice(ioRequest: ADDRESS)
  1263. Arguments:             ioRequest = IORequest structure
  1264. Result:            none
  1265. -------------------------
  1266. CloseFont
  1267. Description:         tells the system that an opened font is no longer in use
  1268. Library:            graphics.library
  1269. Offset:             -$004E (-78)
  1270. Modula-2 Module:     Text
  1271. Syntax:                CloseFont(font)
  1272. C:                    void CloseFont(struct TextFont *)
  1273. Machine Language:     CloseFont(a1)
  1274. Modula-2:        CloseFont(textfont: TextFontPtr)
  1275. Arguments:        font = font descriptor as returned by OpenFont( ) or
  1276.             OpenDiskFont( )
  1277. Result:            none
  1278. -------------------------
  1279. CloseLibrary
  1280. Description:        tells the system that an opened library is no longer in use
  1281. Library:        exec.library
  1282. Offset:            -$019E (-414)
  1283. Modula-2 Module:     Libraries
  1284. Syntax:                CloseLibrary(library)
  1285. C:                   void CloseLibrary(struct Library *)
  1286. Machine Language:     CloseLibrary(a1)
  1287. Modula-2:        CloseLibrary(library: LibraryPtr)
  1288. Arguments:        library = base address of a library, as returned by OpenLibrary( )
  1289. Result:            none
  1290. -------------------------
  1291. CloseScreen
  1292. Description:        closes an Intuition screen
  1293. Library:        intuition.library
  1294. Offset:            -$0042 (-66)
  1295. Modula-2 Module:     Intuition
  1296. Syntax:                CloseScreen(screen)
  1297. C:                    void CloseScreen(struct Screen *)
  1298. Machine Language:     CloseScreen(a0)
  1299. Modula-2:           CloseScreen(screen: ScreenPtr)
  1300. Arguments:             screen = screen to close
  1301. Result:            none
  1302. -------------------------
  1303. CloseWindow
  1304. Description:         closes an Intuition window
  1305. Library:            intuition.library
  1306. Offset:             -$0048 (-72)
  1307. Modula-2 Module:     Intuition
  1308. Syntax:                CloseWindow(window)
  1309. C:                    void CloseWindow(struct Window *)
  1310. Machine Language:     CloseWindow(a0)
  1311. Modula-2:        CloseWindow(window: WindowPtr)
  1312. Arguments:        window = window to close
  1313. Result:            none
  1314. -------------------------
  1315. CloseWorkBench
  1316. Description:        attempts to close the Workbench screen
  1317. Library:        intuition.library
  1318. Offset:            -$004E (-78)
  1319. Modula-2 Module:     Intuition
  1320. Syntax:                success = CloseWorkBench( )
  1321. C:                    long CloseWorkBench(void)
  1322. Machine Language:     d0 = CloseWorkBench( )
  1323. Modula-2:        CloseWorkBench( ): BOOLEAN
  1324. Arguments:        none
  1325. Result:            success = TRUE if successful; FALSE if unsuccessful
  1326. -------------------------
  1327. CMove
  1328. Description:        appends a copper move instruction to a user copper list without
  1329.             bumping the copper instruction pointer to the next instruction
  1330. Library:        graphics.library
  1331. Offset:            -$0174 (-372)
  1332. Modula-2 Module:     Copper
  1333. Syntax:                CMove(copList, r, v)
  1334. C:                    void CMove(struct UCopList *, long, long)
  1335. Machine Language:     CMove(a1, d0, d1)
  1336. Modula-2:        CMove(copList: UCopListPtr; r: ADDRESS; v: WORD)
  1337. Arguments:        copList = UCopList structure
  1338.             a = address of hardware register to receive value
  1339.             v = value to store in hardware register
  1340. Result:            none
  1341. -------------------------
  1342. CMOVE (macro)
  1343. Description:        appends a copper move instruction to a user copper list and
  1344.             bumps the copper instruction pointer to the next instruction
  1345. C Include File:        include/graphics/gfxmacros.h
  1346. ML Include File:    none
  1347. Modula-2 Module:     Copper
  1348. Syntax:                CMOVE(copList, r, v)
  1349. C:                    void CMOVE(struct UCopList *, APTR, short)
  1350. Machine Language:     not available
  1351. Modula-2:        CMOVE(copList: UCopListPtr; r: ADDRESS; v: WORD)
  1352. Arguments:        copList = UCopList structure
  1353.             a = address of hardware register to receive value
  1354.             v = value to store in hardware register
  1355. Result:            none
  1356. -------------------------
  1357. ConcatCList
  1358. Description:        concatenates two character lists
  1359. Library:        clist.library
  1360. Offset:            -$009C (-156)
  1361. Modula-2 Module:     none
  1362. Syntax:                error = ConcatCList(srcCList, destCList)
  1363. C:                    long ConcatCList(long, long)
  1364. Machine Language:     d0 = ConcatCList(a0, a1)
  1365. Modula-2:        not available
  1366. Arguments:        srcCList = source character list
  1367.             destCList = destination character list
  1368. Result:            error = Zero if successful; Nonzero if unsuccessful (out of
  1369.             memory)
  1370. -------------------------
  1371. ConfigBoard
  1372. Description:        configures an expansion board
  1373. Library:        expansion.library
  1374. Offset:            -$003C (-60)
  1375. Modula-2 Module:     Expansion
  1376. Syntax:                error = ConfigBoard(board, configDev)
  1377. C:                    long ConfigBoard(long, long)
  1378. Machine Language:     d0 = ConfigBoard(a0, a1)
  1379. Modula-2:           ConfigBoard(board: ADDRESS; configDev: ADDRESS):
  1380.             BOOLEAN
  1381. Arguments:        board = base address of expansion board (most likely
  1382.             E_EXPANSIONBASE)
  1383.             configDev = initialized ConfigDev structure
  1384. Result:            error = nonzero if unsuccessful
  1385. -------------------------
  1386. ConfigChain
  1387. Description:        configures the entire system
  1388. Library:        expansion.library
  1389. Offset:            -$0042 (-66)
  1390. Modula-2 Module:     Expansion
  1391. Syntax:                error = ConfigChain(baseAddr)
  1392. C:                    long ConfigChain(long)
  1393. Machine Language:     d0 = ConfigChain(a0)
  1394. Modula-2:        ConfigChain(baseAddr: ADDRESS): BOOLEAN
  1395. Arguments:        baseAddr = base address (most likely E_EXPANSIONBASE)
  1396. Result:            error = nonzero if unsuccessful
  1397. -------------------------
  1398. CopyCList
  1399. Description:        copies a character list to a new character list
  1400. Library:        clist.library
  1401. Offset:            -$0090 (-144)
  1402. Modula-2 Module:     none
  1403. Syntax:               cList = CopyCList(cList)
  1404. C:                    long CopyCList(long)
  1405. Machine Language:     d0 = CopyCList(a0)
  1406. Modula-2:        not available
  1407. Arguments:        cList = original character list
  1408. Result:            cList = new character list; Negative is unsuccessful (not enough
  1409.             memory)
  1410. -------------------------
  1411. CopyMem
  1412. Description:        copies the contents of RAM from one location to another
  1413. Library:        exec.library
  1414. Offset:            -$0270 (-624)
  1415. Modula-2 Module:     Memory
  1416. Syntax:                CopyMem(srcPointer, destPointer, size)
  1417. C:                    void CopyMem(char *, char *, long)
  1418. Machine Language:     CopyMem(a0, a1, d0)
  1419. Modula-2:        CopyMem(srcPointer, destPointer: ADDRESS; size: LONGCARD)
  1420. Arguments:        srcPointer = pointer to memory block to be copied
  1421.             destPointer = pointer to destination memory block
  1422.             size = size of memory block in bytes
  1423. Result:            none
  1424. -------------------------
  1425. CopyMemQuick
  1426. Description:        performs an optimized copy of RAM with some restrictions
  1427. Library:        exec.library
  1428. Offset:            -$0276 (-630)
  1429. Modula-2 Module:     Memory
  1430. Syntax:                CopyMemQuick(srcPointer, destPointer, size)
  1431. C:                    void CopyMemQuick(char *, char *, long)
  1432. Machine Language:     CopyMemQuick(a0, a1, d0)
  1433. Modula-2:        CopyMemQuick(srcPointer, destPointer: ADDRESS; size:
  1434.             LONGCARD)
  1435. Arguments:        srcPointer = pointer to the long-word aligned memory block to
  1436.             be copied
  1437.             destPointer = pointer to the long-word aligned destination mem-
  1438.             ory block
  1439.             size = size of memory block in bytes
  1440. Result:            none
  1441. -------------------------
  1442. CopySBitMap
  1443. Description:        copies all bits from a SuperBitMap into the Layer bitmap
  1444. Library:        graphics.library
  1445. Offset:            -$01C2 (-450)
  1446. Modula-2 Module:     Clip
  1447. Syntax:                CopySBitMap(layer)
  1448. C:                    void CopySBitMap(struct Layer *)
  1449. Machine Language:     CopySBitMap(a0)
  1450. Modula-2:        CopySBitMap(layer: LayerPtr)
  1451. Arguments:        layer = pointer to a locked Layer that has a SuperBitMap
  1452. Result:            none
  1453. -------------------------
  1454. CreateBehindlayer
  1455. Description:        creates a new layer behind all existing layers
  1456. Library:        layers.library
  1457. Offset:            -$002A (-42)
  1458. Modula-2 Module:     Layers
  1459. Syntax:                layer = CreateBehindLayer(layerInfo, bitMap, x0, y0, x1, y1, 
  1460.             flags, superBitMap)
  1461. C:                    struct Layer *CreateBehindLayer(struct LayerInfo *, struct Bit-
  1462.             Map *, long, long, long, long, long, struct BitMap *)
  1463. Machine Language:     d0 = CreateBehindLayer(a0, a1, d0, d1, d2, d3, d4, a2)
  1464. Modula-2:        CreateBehindLayer(layerInfo: LayerInfoPtr; bitMap: BitMapPtr; x0,
  1465.             y0, x1, y1: LONGINT; flags: LayerFlagSet; superBitMap:
  1466.             BitMapPtr): LayerPtr
  1467. Arguments:        layerInfo = info structure of Layer to create
  1468.             bitMap = common BitMap used by all Layers
  1469.             x0 = horizontal coordinate of upper left corner of Layer
  1470.             y0 = vertical coordinate of upper left corner of Layer
  1471.             x1 = horizontal coordinate of lower right corner of Layer
  1472.             y1 = vertical coordinate of lower right corner of Layer
  1473.             flags = type of Layer
  1474.             superBitMap = NULL or a SuperBitMap
  1475. Result:            layer = pointer to Layer structure if successful; NULL if
  1476.             unsuccessful
  1477. -------------------------
  1478. CreateDir
  1479. Description:        creates a new directory
  1480. Library:        dos.library
  1481. Offset:            -$0078 (-120)
  1482. Modula-2 Module:     DOS
  1483. Syntax:                lock = CreateDir(name)
  1484. C:                    BPTR CreateDir(char *)
  1485. Machine Language:     d0 = CreateDir(d1)
  1486. Modula-2:        CreateDir(name: STRPTR): FileLock
  1487. Arguments:        name = NULL terminate string that specifies the new directory
  1488.             name
  1489. Result:            lock = BCPL pointer to a lock
  1490. -------------------------
  1491. CreateExtIO
  1492. Description:        allocates memory for and initializes an IO request block
  1493. Library:        amiga.lib (linked library)
  1494. Modula-2 Module:     IOUtils
  1495. Syntax:                block = CreateExtIO(ioReplyPort, size)
  1496. C:                    struct IORequest *CreateExtIO(struct MsgPort *, long)
  1497. Machine Language:     move.l #size,-(sp)
  1498.             pea ioReplyPort
  1499.             jsr _CreateExtIO ;block returned in d0
  1500.             addq.l #8,sp
  1501. Modula-2:        CreateExtIO(ioReplyPort: MsgPortPtr; size: CARDINAL):
  1502.             ADDRESS
  1503. Arguments:        ioReplyPort = initialized MsgPort
  1504.             size = IORequest block size
  1505. Result:            block = pointer to newly created IORequest block; NULL if un-
  1506.             successful (not enough memory)
  1507. -------------------------
  1508. CreatePort
  1509. Description:        allocates memory for and initializes a message port
  1510. Library:        amiga.lib (linked library)
  1511. Modula-2 Module:     PortUtils
  1512. Syntax:                port = CreatePort(name, pri)
  1513. C:                    struct MsgPort *CreatePort(char *, long)
  1514. Machine Language:     move.l #pri,-(sp)
  1515.             pea name
  1516.             jsr _CreatePort ;port returned in d0
  1517.             addq.l #8,sp
  1518. Modula-2:        CreatePort(name: STRPTR; pri: INTEGER): MsgPortPtr
  1519. Arguments:        name = name of public port to create; NULL for private port
  1520.             pri = priority to assign to port
  1521. Result:            port = pointer to newly created message port; NULL if unsuc-
  1522.             cessful (not enough memory)
  1523. -------------------------
  1524. CreateProc
  1525. Description:        creates a new process
  1526. Library:        dos.library
  1527. Offset:            -$008A (-138)
  1528. Modula-2 Module:     DOSProcess
  1529. Syntax:                process = CreateProc(name, pri, segment, stackSize)
  1530. C:                    struct MsgPort *CreateProc(char *, long, BPTR, long)
  1531. Machine Language:     d0 = CreateProc(d1, d2, d3, d4)
  1532. Modula-2:        CreateProc(name: STRPTR; pri: LONGINT; segment: BPTR;
  1533.             stackSize: LONGINT): ProcessID
  1534. Arguments:        name = NULL terminated string that specifies the new process
  1535.             name
  1536.             priority = priority to be given to process
  1537.             segment = segment list, as returned by LoadSeg( )
  1538.             stackSize = size of root stack in bytes
  1539. Result:            process = pointer to newly created IORequest block; NULL if un-
  1540.             successful (not enough memory)
  1541. -------------------------
  1542. CreateTask
  1543. Description:        creates a task
  1544. Library:            amiga.lib (linked library)
  1545. Modula-2 Module:     TaskUtils
  1546. Syntax:               task = CreateTask(name, pri, initPC, stackSize)
  1547. C:                    struct Task *CreateTask(char *, long, _fptr, long)
  1548. Machine Language:     move.l #stackSize,-(sp)
  1549.             pea initPC
  1550.             move.l #pri,-(sp)
  1551.             pea name
  1552.             jsr _CreateTask ;task returned in d0
  1553.             add.l #16,sp
  1554. Modula-2:        CreateTask(name: STRPTR; pri: INTEGER; initP
  1555. C:            PROC; stackSize: LONGCARD): TaskPtr
  1556. Arguments:        name = name of task
  1557.             pri = exec task priority (-128 through 127, usually 0)
  1558.             stackSize = size of stack in bytes
  1559. Result:            task = pointer to newly created task; NULL if unsuccessful (not
  1560.             enough memory)
  1561. -------------------------
  1562. CreateUpfrontLayer
  1563. Description:        creates a new layer on top of all existing layers
  1564. Library:        layers.library
  1565. Offset:                -$0024 (-36)
  1566. Modula-2 Module:     Layers
  1567. Syntax:                layer = CreateUpfrontLayer(layerInfo, bitMap, x0, y0, x1, y1, 
  1568.             flags, superBitMap)
  1569. C:                struct Layer *CreateUpfrontLayer(struct Layer_Info *, struct Bit-
  1570.             Map *, long, long, long, long, long, struct BitMap *)
  1571. Machine Language:     d0 = CreateUpfrontLayer(a0, a1, d0, d1, d2, d3, d4, a2)
  1572. Modula-2:        CreateUpfrontLayer(layerInfo: LayerInfoPtr; bitMap: BitMapPtr;
  1573.             x0, y0, x1, y1: LONGINT; flags: LayerFlagSet; superBitMap:
  1574.             BitMapPtr): LayerPtr
  1575. Arguments:        layerInfo = info structure of Layer to create
  1576.             bitMap = common BitMap used by all Layers
  1577.             x0 = horizontal coordinate of upper left corner of Layer
  1578.             y0 = vertical coordinate of upper left corner of Layer
  1579.             x1 = horizontal coordinate of lower right corner of Layer
  1580.             y1 = vertical coordinate of lower right corner of Layer
  1581.             flags = type of Layer
  1582.             superBitMap = NULL or pointer to SuperBitMap
  1583. Result:            layer = pointer to Layer structure if successful; NULL if
  1584.             unsuccessful
  1585. -------------------------   
  1586. CurrentDir
  1587. Description:        changes the current directory and returns the old current directory
  1588. Library:            dos.library
  1589. Offset:             -$007E (-126)
  1590. Modula-2 Module:     DOS
  1591. Syntax:                oldlock = CurrentDir(lock)
  1592. C:                    BPTR CurrentDir(BPTR)
  1593. Machine Language:     d0 = CurrentDir(d1)
  1594. Modula-2:        CurrentDir(lock: FileLock): FileLock
  1595. Arguments:        lock = BCPL pointer to lock associated with new current
  1596.             directory
  1597. Result:            oldlock = BCPL pointer to lock associated with old directory
  1598. -------------------------
  1599. CurrentTime
  1600. Description:        returns the current system time
  1601. Library:        intuition.library
  1602. Offset:               -$0054 (-84)
  1603. Modula-2 Module:     Intuition
  1604. Syntax:                CurrentTime(seconds, micros)
  1605. C:                    void CurrentTime(long *, long *)
  1606. Machine Language:     CurrentTime(d0, d1)
  1607. Modula-2:        CurrentTime(VAR seconds, micros: LONGCARD)
  1608. Arguments:        seconds = pointer to four-byte (LONG) variable to receive sec-
  1609.             onds value
  1610.             micros = pointer to four-byte (LONG) variable to receive micro-
  1611.             seconds value
  1612. Result:            returned in seconds and micros arguments
  1613. -------------------------
  1614. CWait
  1615. Description:        appends copper wait instruction to a user copper list without
  1616.             bumping the copper instruction pointer to the next instruction
  1617. Library:        graphics.library
  1618. Offset:               -$017A (-378)
  1619. Modula-2 Module:     CopperUtil
  1620. Syntax:                CWait(copList, vert, horiz)
  1621. C:                    void CWait(struct UCopList *, short, short)
  1622. Machine Language:     not available
  1623. Modula-2:        CWait(copList: UCopListPtr; vert, horiz: INTEGER)
  1624. Arguments:        copList = UCopList structure
  1625.             vert = vertical beam position relative to top of ViewPort
  1626.             horiz = horizontal beam position (must be less than 223)
  1627. Result:            none
  1628. -------------------------
  1629. CWAIT (macro)
  1630. Description:        appends copper wait instruction to a user copper list and bumps
  1631.             the copper instruction pointer to the next instruction
  1632. C Include File:        include/graphics/gfxmacros.h
  1633. ML Include File:    none
  1634. Modula-2 Module:    CopperUtil
  1635. Syntax:                CWAIT(copList, vert, horiz)
  1636. C:                    void CWAIT(struct UCopList *, short, short)
  1637. Machine Language:     not available
  1638. Modula-2:        CWAIT(copList: UCopListPtr; vert, horiz: INTEGER)
  1639. Arguments:        copList = UCopList structure
  1640.             vert = vertical beam position relative to top of ViewPort
  1641.             horiz = horizontal beam position (must be less than 223)
  1642. Result:            none
  1643. -------------------------
  1644. DateStamp
  1645. Description:        returns the current date and time in internal format
  1646. Library:        dos.library
  1647. Offset:               -$00C0 (-192)
  1648. Modula-2 Module:     DOS
  1649. Syntax:                DateStamp(v)
  1650. C:                    long *DateStamp(long *)
  1651. Machine Language:     DateStamp(d1)
  1652. Modula-2:        DateStamp(v: DateStampRecPtr)
  1653. Arguments:        v = pointer to the first element of an array of three long words
  1654. Result:            v argument points to result in RAM
  1655. -------------------------
  1656. dbf
  1657. Description:        converts a fast floating point dual-binary number to plain fast
  1658.             floating point format
  1659. Library:        amiga.lib (linked library)
  1660. Modula-2 Module:     none
  1661. Syntax:                fnum = dbf(exp, mant)
  1662. C:            float dbf(long, long)
  1663. Machine Language:     move.l #mant,-(sp)
  1664.             move.l #exp,-(sp) 
  1665.             jsr _dfb ;fnum returned in d0/d1 
  1666.             addq.l #8,sp
  1667. Modula-2:        not available
  1668. Arguments:        exp = 16 bit integer representing the sign (bit 16 equals 0 for
  1669.             positive or 1 for negative) and base ten exponent (bits 0-15)
  1670.             mant = integer representing the mantissa
  1671. Result:            fnum = floating point equivalent of value specified by exp and
  1672.             mant arguments
  1673. -------------------------
  1674. Deallocate
  1675. Description:        deallocates a block of previously allocated memory
  1676. Library:        exec.library
  1677. Offset:               -$00C0 (-192)
  1678. Modula-2 Module:     Memory
  1679. Syntax:                Deallocate(freeList, memoryBlock, byteSize)
  1680. C:                    void Deallocate(struct MemHeader *, void *, long)
  1681. Machine Language:     Deallocate(a0, a1, d0)
  1682. Modula-2:        Deallocate(freeList: MemHeaderPtr; memoryBlock: ADDRESS;
  1683.             byteSize: LONGCARD)
  1684. Arguments:        freeList = memory list header
  1685.             memoryBlock = memory block to deallocate
  1686.             byteSize = size of memory block in bytes
  1687. Result:            none
  1688. -------------------------
  1689. Debug
  1690. Description:        runs the system debugger or the debugger installed by
  1691.             SetFunction
  1692. Library:        exec.library
  1693. Offset:               -$0072 (-114)
  1694. Modula-2 Module:     Exec
  1695. Syntax:                Debug(num)
  1696. C:                    void Debug(long)
  1697. Machine Language:     Debug(d0)
  1698. Modula-2:              Debug(num: LONGCARD)
  1699. Arguments:             num = should be set to 0
  1700. Result:            none
  1701. -------------------------  
  1702. Delay
  1703. Description:         delays a process for a specified amount of time
  1704. Library:            dos.library
  1705. Offset:             -$00C6 (-198)
  1706. Modula-2 Module:     DOSProcess
  1707. Syntax:                Delay(ticks)
  1708. C:                    void Delay(long)
  1709. Machine Language:     Delay(d1)
  1710. Modula-2:        Delay(ticks: LONGINT)
  1711. Arguments:        ticks = number of ticks to wait (50 ticks per second)
  1712. Result:    none
  1713. -------------------------
  1714. DeleteExtIO
  1715. Description:        returns memory allocated by CreateExtIO
  1716. Library:        amiga.lib (linked library)
  1717. Modula-2 Module:     IOUtils
  1718. Syntax:                DeleteExtIO(ioRequest, size)
  1719. C:                    void DeleteExtIO(struct IORequest *, long)
  1720. Machine Language:     move.l #size,-(sp)
  1721.             pea ioRequest
  1722.             jsr _DeleteExtIO
  1723.             addq.l #4,sp
  1724. Modula-2:        DeleteExtIO(ioReq: ADDRESS; size: CARDINAL)
  1725. Arguments:        ioRequest = IORequest block to delete
  1726.             size = size of IORequest block in bytes
  1727. Result:            none
  1728. -------------------------
  1729. DeleteFile
  1730. Description:        deletes a file or directory
  1731. Library:        dos.library
  1732. Offset:               -$0048 (-72)
  1733. Modula-2 Module:     DOS
  1734. Syntax:                success = DeleteFile(name)
  1735. C:                    long DeleteFile(char *)
  1736. Machine Language:     d0 = DeleteFile(d1)
  1737. Modula-2:           DeleteFile(name: STRPTR): BOOLEAN
  1738. Arguments:          name = NULL terminated string that specifies the file to delete
  1739. Result:            TRUE if successful; FALSE if unsuccessful
  1740. -------------------------
  1741. DeleteLayer
  1742. Description:        deletes a layer from a layer list
  1743. Library:            layers.library
  1744. Offset:             -$005A (-90)
  1745. Modula-2 Module:     Layers
  1746. Syntax:                success = DeleteLayer(dummy, layer)
  1747. C:                    long DeleteLayer(struct Layer_Info, struct Layer *)
  1748. Machine Language:     d0 = DeleteLayer(a0, a1)
  1749. Modula-2:        DeleteLayer(layer: LayerPtr): BOOLEAN
  1750. Arguments:        dummy = unused
  1751.             layer = layer to delete
  1752. Result:            success = TRUE if successful; FALSE if unsuccessful
  1753. -------------------------
  1754. DeletePort
  1755. Description:        frees a message port created by CreatePort( )
  1756. Library:        amiga.lib (linked library)
  1757. Modula-2 Module:     PortUtils
  1758. Syntax:                DeletePort(msgPort)
  1759. C:                    void DeletePort(struct MsgPort *)
  1760. Machine Language:     pea msgPort
  1761.             jsr _DeletePort
  1762.             addq.l #4,sp
  1763. Modula-2:        DeletePort(msgPort: MsgPortPtr)
  1764. Arguments:        msgPort = message port to delete
  1765. Result:            none
  1766. -------------------------
  1767. DeleteTask
  1768. Description:        deletes a task created with CreateTask( )
  1769. Library:        amiga.lib (linked library)
  1770. Modula-2 Module:     TaskUtils
  1771. Syntax:                DeleteTask(task)
  1772. C:                    void DeleteTask(struct Task *)
  1773. Machine Language:     pea task
  1774.             jsr _DeleteTask
  1775.             addq.l #4,sp
  1776. Modula-2:        DeleteTask(task: TaskPtr)
  1777. Arguments:        task = Task to delete
  1778. Result:            none
  1779. -------------------------
  1780. DeviceProc
  1781. Description:        returns the process identifier of specified process
  1782. Library:            dos.library
  1783. Offset:             -$00AE (-174)
  1784. Modula-2 Module:     DOSProcess
  1785. Syntax:                process = DeviceProc(name)
  1786. C:                    struct MsgPort *DeviceProc(char *)
  1787. Machine Language:     d0 = DeviceProc(d1)
  1788. Modula-2:        DeviceProc(name: STRPTR): ProcessID
  1789. Arguments:        name = NULL terminated string that specifies the device name
  1790. Result:            process = BCPL pointer to a process; NULL if unsuccessful
  1791. -------------------------
  1792. Disable
  1793. Description:        disables interrupt processing
  1794. Library:        exec.library
  1795. Offset:                -$0078 (-120)
  1796. Modula-2 Module:     Interrupts
  1797. Syntax:                Disable( )
  1798. C:                    void Disable(void)
  1799. Machine Language:     Disable( )
  1800. Modula-2:        Disable( )
  1801. Arguments:        none
  1802. Result:            none
  1803. -------------------------
  1804. DisownBlitter
  1805. Description:        frees blitter for use by other programs
  1806. Library:        graphics.library
  1807. Offset:                -$01CE (-462)
  1808. Modula-2 Module:     Blitter
  1809. Syntax:                DisownBlitter( )
  1810. C:                    void DisownBlitter(void)
  1811. Machine Language:     DisownBlitter( )
  1812. Modula-2:           DisownBlitter( )
  1813. Arguments:          none
  1814. Result:            none
  1815. -------------------------
  1816. DisplayAlert
  1817. Description:         creates an Alert
  1818. Library:            intuition.library
  1819. Offset:             -$005A (-90)
  1820. Modula-2 Module:     Intuition
  1821. Syntax:                response = DisplayAlert(alertNumber, message, height)
  1822. C:                    long DisplayAlert(long, char *, long)
  1823. Machine Language:     d0 = DisplayAlert(d0, a0, d1)
  1824. Modula-2:        DisplayAlert(alertNumber: LONGCARD; message: ADDRESS;
  1825.             height: CARDINAL): BOOLEAN
  1826. Arguments:        alertNumber = AlertMessage number
  1827.             message = NULL terminated Alert message string
  1828.             height = minimum display lines required for your message
  1829. Result:            response = TRUE or FALSE, depending on alert type and user
  1830.             response
  1831. -------------------------
  1832. DisplayBeep
  1833. Description:        flashes the video display and emits a beep
  1834. Library:        intuition.library
  1835. Offset:               -$0060 (-96)
  1836. Modula-2 Module:     Intuition
  1837. Syntax:                DisplayBeep(screen)
  1838. C:                    void DisplayBeep(struct Screen *)
  1839. Machine Language:     DisplayBeep(a0)
  1840. Modula-2:           DisplayBeep(screen: ScreenPtr)
  1841. Arguments:             screen = screen to beep
  1842. Result:                none
  1843. -------------------------
  1844. DisposeFontContents (available in library version 34)
  1845. Description:         frees the array of FontContents returned by NewFontContents( )
  1846. Library:            diskfont.library
  1847. Offset:             -$0030 (-48)
  1848. Modula-2 Module:     none
  1849. Syntax:                DisposeFontContents(fontContentsHeader)
  1850. C:                    void DisposeFontContents(struct FontContentsHeader *)
  1851. Machine Language:     DisposeFontContents(a1)
  1852. Modula-2:           not available
  1853. Arguments:             fontContentsHeader = FontContentsHeader as returned by
  1854.             NewFontContents( )
  1855. Result:            none
  1856. -------------------------  
  1857. DisposeLayerInfo
  1858. Description:        returns memory used by a LayerInfo structure
  1859. Library:            layers.library
  1860. Offset:             -$0096 (-150)
  1861. Modula-2 Module:     Layers
  1862. Syntax:                DisposeLayerInfo(layerInfo)
  1863. C:                    void DisposeLayerInfo(struct Layer_Info *)
  1864. Machine Language:     DisposeLayerInfo(a0)
  1865. Modula-2:        DisposeLayerInfo(layerInfo: layerInfoPtr)
  1866. Arguments:        layerInfo = LayerInfo structure to remove
  1867. Result:            none
  1868. -------------------------
  1869. DisposeRegion
  1870. Description:        returns memory used by a Region structure and its
  1871.             RegionRectangles
  1872. Library:        graphics.library
  1873. Offset:                -$0216 (-534)
  1874. Modula-2 Module:     Regions
  1875. Syntax:                DisposeRegion(region)
  1876. C:                    void DisposeRegion(struct Region *)
  1877. Machine Language:     DisposeRegion(a0)
  1878. Modula-2:        DisposeRegion(region: RegionPtr)
  1879. Arguments:        region = Region structure to remove
  1880. Result:            none
  1881. -------------------------
  1882. DoCollision
  1883. Description:        tests all GELs in GEL list for GEL-to-GEL collisions
  1884. Library:        graphics.library
  1885. Offset:                -$006C (-108)
  1886. Modula-2 Module:     Gels
  1887. Syntax:                DoCollision(rastPort)
  1888. C:                    void DoCollision(struct RastPort *)
  1889. Machine Language:     DoCollision(a1)
  1890. Modula-2:           DoCollision(rastPort: RastPortPtr)
  1891. Arguments:             rastPort = RastPort with GEL list
  1892. Result:            none
  1893. -------------------------  
  1894. DoIO
  1895. Description:        performs IO command and waits for completion
  1896. Library:               exec.library
  1897. Offset:                -$01C8 (-465)
  1898. Modula-2 Module:     IO
  1899. Syntax:                error = DoIO(ioRequest)
  1900. C:                    long DoIO(struct IORequest *)
  1901. Machine Language:     d0 = DoIO(a1)
  1902. Modula-2:        DoIO(ioRequest: ADDRESS): INTEGER
  1903. Arguments:        ioRequest = initialized IORequest structure
  1904. Result:            error = zero if successful; nonzero if unsuccessful
  1905. -------------------------
  1906. DoubleClick
  1907. Description:        test two time values for double-click timing
  1908. Library:        intuition.library
  1909. Offset:               -$0066 (-102)
  1910. Modula-2 Module:     Intuition
  1911. Syntax:                double = DoubleClick(startSecs, startMicros, currentSecs,
  1912.             currentMicros)
  1913. C:                    long DoubleClick(long, long, long, long)
  1914. Machine Language:     d0 = DoubleClick(d0, d1, d2, d3)
  1915. Modula-2:        DoubleClick(startSecs, startMicros, currentSecs, currentMicros:
  1916.             LONGCARD): BOOLEAN
  1917. Arguments:        startSecs = seconds value at time of first click
  1918.             startMicros = micros value at time of first click
  1919.             currentSecs = seconds value at time of second click
  1920.             currentMicros = micros value at time of second click
  1921. Result:            double = TRUE if valid double click; FALSE if not
  1922. -------------------------
  1923. Draw
  1924. Description:        draws a line from current pen position to specified point
  1925. Library:        graphics.library
  1926. Offset:               -$00F6 (-246)
  1927. Modula-2 Module:     Pens
  1928. Syntax:                Draw(rastPort, x, y)
  1929. C:                    long Draw(struct RastPort *, long, long)
  1930. Machine Language:    Draw(a1, d0, d1)
  1931. Modula-2:        Draw(rastPort: RastPortPtr; x, y: INTEGER)
  1932. Arguments:        rastPort = RastPort to draw line in
  1933.             x = horizontal coordinate of line's destination
  1934.             y = vertical coordinate of line's destination
  1935. Result:            none
  1936. -------------------------
  1937. DrawBorder
  1938. Description:        draws a border
  1939. Library:        intuition.library
  1940. Offset:               -$006C (-108)
  1941. Modula-2 Module:     Intuition
  1942. Syntax:                DrawBorder(rastPort, border, leftOffset, topOffset)
  1943. C:                    long DrawBorder(struct RastPort *, struct Border *, long, long)
  1944. Machine Language:     DrawBorder(a0, a1, d0, d1)
  1945. Modula-2:        DrawBorder(rastPort: RastPortPtr; border: BorderPtr; leftOffset,
  1946.             topOffset: INTEGER)
  1947. Arguments:        rastPort = RastPort to draw border in
  1948.             border = Border to be drawn
  1949.             leftOffset = horizontal placement offset for border
  1950.             topOffset = vertical placement offset for border
  1951. Result:            none
  1952. -------------------------
  1953. DrawCircle (macro)
  1954. Description:         draws a circle in the specified RastPort
  1955. C Include File:     include/graphics/gfxmacros.h
  1956. ML Include File:     none
  1957. Modula-2 Module:     Pens
  1958. Syntax:                DrawCircle(rastPort, cx, cy, radius)
  1959. C:                    void DrawCircle(struct RastPort *, long, long, long)
  1960. Machine Language:     not available, use DrawEllipse instead
  1961. Modula-2:        DrawCircle(rastPort: RastPortPtr; cx, cy, radius: INTEGER)
  1962. Arguments:        rastPort = RastPort structure
  1963.             cx = horizontal coordinate of circle's center
  1964.             cy = vertical coordinate of circle's center
  1965.             radius = circle's radius
  1966. Result:            none
  1967. -------------------------
  1968. DrawEllipse
  1969. Description:         draws an elliptical outline within a rectangular outline
  1970. Library:               graphics.library
  1971. Offset:             -$00B4 (-180)
  1972. Modula-2 Module:     Pens
  1973. Syntax:                DrawEllipse(rastPort, cx, cy, a, b)
  1974. C:                    void DrawEllipse(struct RastPort *, long, long, long, long)
  1975. Machine Language:     DrawEllipse(a1, d0, d1, d2, d3)
  1976. Modula-2:        DrawEllipse(rastPort: RastPortPtr; cx, cy, a, b: INTEGER)
  1977. Arguments:        rastPort = RastPort into which ellipse will be drawn
  1978.             cx = horizontal coordinate of ellipse's center, relative to the
  1979.             RastPort
  1980.             cy = vertical coordinate of ellipse's center, relative to the RastPort
  1981.             a = ellipse's horizontal radius (must be greater than O)
  1982.             b = ellipse's vertical radius (must be greater than O)
  1983. Result:            none
  1984. -------------------------
  1985. DrawGList
  1986. Description:        processes a GEL list, drawing bobs and constructing a copper list
  1987.             for VSprites
  1988. Library:        graphics.library
  1989. Offset:               -$0072 (-114)
  1990. Modula-2 Module:     Gels
  1991. Syntax:                DrawGList(rastPort, viewPort)
  1992. C:                    void DrawGList(struct RastPort *, struct ViewPort *)
  1993. Machine Language:     DrawGList(a1, a0)
  1994. Modula-2:        DrawGList(rastPort: RastPortPtr; viewPort: ViewPortPtr)
  1995. Arguments:        rastPort = RastPort where bobs will be drawn
  1996.             viewPort = ViewPort in which VSprites will be created
  1997. Result:            none
  1998. -------------------------
  1999. DrawImage
  2000. Description:        draw the specified image
  2001. Library:        intuition.library
  2002. Offset:               -$0072 (-114)
  2003. Modula-2 Module:    Intuition
  2004. Syntax:               DrawImage(rastPort, image, leftOffset, topOffset)
  2005. C:                    long DrawImage(struct RastPort *, struct Image *, long, long)
  2006. Machine Language:     DrawImage(a0, a1, d0, d1)
  2007. Modula-2:        DrawImage(rastPort: RastPortPtr; image: ImagePtr; leftOffset,
  2008.             topOffset: INTEGER)
  2009. Arguments:        rastPort = RastPort where image will be drawn
  2010.             image = Image to be drawn
  2011.             leftOffset = horizontal placement offset for image
  2012.             topOffset = vertical placement offset for image
  2013. Result:            none
  2014. -------------------------
  2015. Duplock
  2016. Description:        duplicates a lock
  2017. Library:        dos.library
  2018. Offset:               -$0060 (-96)
  2019. Modula-2 Module:     DOS
  2020. Syntax:                newlock = DupLock(lock)
  2021. C:                    BPTR DupLock(BPTR)
  2022. Machine Language:     d0 = DupLock(d1)
  2023. Modula-2:        DupLock(lock: FileLock): FileLock
  2024. Arguments:        lock = lock to duplicate
  2025. Result:            newlock = duplicate lock
  2026. -------------------------
  2027. Enable
  2028. Description:        enables interrupt processing
  2029. Library:        exec.library
  2030. Offset:               -$007E (-126)
  2031. Modula-2 Module:     Interrupts
  2032. Syntax:                Enable( )
  2033. C:                    void Enable(void)
  2034. Machine Language:     Enable( )
  2035. Modula-2:        Enable( )
  2036. Arguments:        none
  2037. Result:            none
  2038. -------------------------
  2039. EndRefresh
  2040. Description:        ends optimized refresh of a window
  2041. Library:        intuition.library
  2042. Offset:               -$016E (-366)
  2043. Modula-2 Module:     Intuition
  2044. Syntax:                EndRefresh(window, complete)
  2045. C:                    void EndRefresh(struct Window *, long)
  2046. Machine Language:     EndRefresh(a0, d0)
  2047. Modula-2:        EndRefresh(window: WindowPtr; complete: BOOLEAN)
  2048. Arguments:        window = window in optimized-refresh mode
  2049.             complete = TRUE if window is completely refreshed; FALSE if
  2050.             not
  2051. Result:            none
  2052. -------------------------
  2053. EndRequest
  2054. Description:        removes requester from window
  2055. Library:        intuition.library
  2056. Offset:               -$0078 (-120)
  2057. Modula-2 Module:     Intuition
  2058. Syntax:                EndRequest(requester, window)
  2059. C:                    void EndRequest(struct Requester *, struct Window *)
  2060. Machine Language:     EndRequest(a0, a1)
  2061. Modula-2:        EndRequest(requester: RequesterPtr; window: WindowPtr)
  2062. Arguments:        requester = requester to remove
  2063.             window = window which is associated with requester
  2064. Result:            none
  2065. -------------------------
  2066. EndUpdate
  2067. Description:        removes damage list and restores layer to normal state
  2068. Library:        layers.library
  2069. Offset:               -$0054 (-84)
  2070. Modula-2 Module:    Layers
  2071. Syntax:                EndUpdate(layer, flag)
  2072. C:                    void EndUpdate(struct Layer *, long)
  2073. Machine Language:     EndUpdate(a0, d0)
  2074. Modula-2:        EndUpdate(layer: LayerPtr; flag: BOOLEAN)
  2075. Arguments:        layer = layer to return to normal state
  2076.             flag = TRUE if update was complete-damage list will be
  2077.             cleared; FALSE if update was not complete-damage list will be
  2078.             retained
  2079. Result:    none
  2080. -------------------------
  2081. Enqueue
  2082. Description:        inserts or appends node to a system queue
  2083. Library:        exec.library
  2084. Offset:               -$010E (-270)
  2085. Modula-2 Module:     Lists
  2086. Syntax:            Enqueue(list, node)
  2087. C:                 void Enqueue(struct List *, struct Node *)
  2088. Machine Language:     Enqueue(a0, a0)
  2089. Modula-2:        Enqueue(list: ListPtr; node: NodePtr)
  2090. Arguments:        list = system queue header
  2091.             node = node to insert or append
  2092. Result:            none
  2093. -------------------------
  2094. Examine
  2095. Description:        examines a directory or file
  2096. Library:        dos.library
  2097. Offset:               -$0066 (-102)
  2098. Modula-2 Module:     DOS
  2099. Syntax:                success = Examine(lock, infoBlock)
  2100. C:                    long Examine(BPTR, struct FileInfoBlock *)
  2101. Machine Language:     d0 = Examine(d1, d2)
  2102. Modula-2:        Examine(lock: FileLock; infoBlock: FileInfoBlockPtr): BOOLEAN
  2103. Arguments:        lock = lock of directory or file to examine
  2104.             infoBlock = info block to receive directory or file information
  2105. Result:            success = TRUE if successful; FALSE if unsuccessful
  2106. -------------------------
  2107. Execute
  2108. Description:        executes a CLI command
  2109. Library:        dos.library
  2110. Offset:               -$00DE (-222)
  2111. Modula-2 Module:     DOSLoader
  2112. Syntax:                success = Execute(command, input, output)
  2113. C:                    long Execute(char *, BPTR, BPTR)
  2114. Machine Language:     d0 = Execute(d1, d2, d3)
  2115. Modula-2:        Execute(command: STRPTR; input, output: FileHandle):
  2116.             BOOLEAN
  2117. Arguments:        command = NULL terminated string containing CLI command
  2118.             input = file handle for input redirection; NULL if none
  2119.             output = file handle for output redirection; NULL if none
  2120. Result:            success = TRUE if successful; FALSE if unsuccessful
  2121. -------------------------
  2122. Exit
  2123. Description:        ends a program
  2124. Library:        dos.library
  2125. Offset:               -$0090 (-144)
  2126. Modula-2 Module:     DOSProcess
  2127. Syntax:                Exit(returnCode)
  2128. C:                    void Exit(long)
  2129. Machine Language:     Exit(d1)
  2130. Modula-2:        Exit(returnCode: LONGINT)
  2131. Arguments:        returnCode = return code passed to parent (usually the CLI)-by
  2132.             convention, a value of zero implies no error
  2133. Result:            none
  2134. -------------------------
  2135. ExNext
  2136. Description:        examines the next entry in a directory
  2137. Library:        dos.library
  2138. Offset:             -$006C (-108)
  2139. Modula-2 Module:     DOS
  2140. Syntax:                success = ExNext(lock, infoBlock)
  2141. C:                    long ExNext(BPTR, struct FilelnfoBlock *)
  2142. Machine Language:     d0 = ExNext(d1, d2)
  2143. Modula-2:        ExNext(lock: FileLock; infoBlock: FileInfoBlockPtr): BOOLEAN
  2144. Arguments:        lock = lock of directory to examine
  2145.             infoBlock = info block to receive entry information
  2146. Result:            success = TRUE if successful; FALSE if unsuccessful
  2147. -------------------------
  2148. FastRand
  2149. Description:        generates a somewhat random integer
  2150. Library:        amiga.lib (linked library)
  2151. Modula-2 Module:     none
  2152. Syntax:                rnd = FastRand(seed)
  2153. C:                    long FastRand(long)
  2154. Machine Language:     move.l #long,-(sp)
  2155.             jsr _FastRand ;rnd returned in d0
  2156.             addq.l #4,sp
  2157. Modula-2:        not available, use Random in RandomNumbers module
  2158. Arguments:        seed = value used to seed random number
  2159. Result:            rnd = random number calculate using the following C equation:
  2160.             rnd=(seed << 1) ^ 0x1872B41
  2161. -------------------------
  2162. FattenLayerInfo
  2163. Description:        converts 1.0 LayerInfo structure to 1.1-1.3-compatible LayerInfo
  2164.             structure
  2165. Library:        layers.library
  2166. Offset:             -$009C (-156)
  2167. Modula-2 Module:     none
  2168. Syntax:                FattenLayerInfo(layerInfo)
  2169. C:                    void FattenLayerInfo(struct Layer_Info *)
  2170. Machine Language:     FattenLayerInfo(a0)
  2171. Modula-2:        not available
  2172. Arguments:        layerInfo = LayerInfo structure to update
  2173. Result:            none
  2174. -------------------------
  2175. FindConfigBoard
  2176. Description:        finds a matching ConfigDev entry
  2177. Library:        expansion.library
  2178. Offset:              -$0048 (-72)
  2179. Modula-2 Module:     none
  2180. Syntax:                configDev = FindConfigBoard(oldConfigDev, manufacturer,
  2181.             product)
  2182. C:                    struct ConfigDev *FindConfigBoard(long, long, long)
  2183. Machine Language:     d0 = FindConfigBoard(a0, d0, d1)
  2184. Modula-2:        not available
  2185. Arguments:        oldConfigDev = ConfigDev structure just before the location in
  2186.             ConfigDev list where search should begin; NULL to start search at
  2187.             the beginning of the list
  2188.             manufacturer = manufacturer code to search for; -1 to ignore
  2189.             manufacturer code
  2190.             product = product code to search for; -1 to ignore product coed
  2191. Result:            configDev = first ConfigDev structure that matches the manufac-
  2192.             turer and product codes specified; NULL if no more matches
  2193. -------------------------
  2194. FindName
  2195. Description:        finds a system list node
  2196. Library:        exec.library
  2197. Offset:             -$0114 (-276)
  2198. Modula-2 Module:     Lists
  2199. Syntax:                node = FindName(start, name)
  2200. C:                    struct Node *FindName(struct List *, char *)
  2201. Machine Language:     d0 = FindName(a0, a1)
  2202. Modula-2:        FindName(start: ADDRESS; name: STRPTR): NodePtr
  2203. Arguments:        start = list header or list node to start search (if node this one is
  2204.             skipped)
  2205.             name = NULL terminated string that specifies name of node
  2206. Result:            node = pointer to specified node; NULL if unsuccessful
  2207. -------------------------  
  2208. FindPort
  2209. Description:         finds a public message port
  2210. Library:            exec.library
  2211. Offset:             -$0186 (-390)
  2212. Modula-2 Module:     Ports
  2213. Syntax:                port = FindPort(name)
  2214. C:                    struct MsgPort *FindPort(char *)
  2215. Machine Language:     d0 = FindPort(a1)
  2216. Modula-2:        FindPort(name: STRPTR): MsgPortPtr
  2217. Arguments:        name = NULL terminated string that specifies name of port
  2218. Result:            port = pointer to specified port; NULL if unsuccessful
  2219. -------------------------
  2220. FindResident
  2221. Description:        finds a Resident structure
  2222. Library:        exec.library
  2223. Offset:                -$0060 (-96)
  2224. Modula-2 Module:     Resident
  2225. Syntax:                resident = FindResident(name)
  2226. C:                    struct Resident *FindResident(char *)
  2227. Machine Language:     d0 = FindResident(a1)
  2228. Modula-2:        FindResident(name: STRPTR): ResidentPtr
  2229. Arguments:        name = NULL terminated string that specifies name of Resident
  2230.             structure
  2231. Result:            resident = pointer to specified Resident structure; NULL if
  2232.             unsuccessful
  2233. -------------------------
  2234. FindSemaphore
  2235. Description:        finds a SignalSemaphore structure
  2236. Library:        exec.library
  2237. Offset:                -$0252 (-612)
  2238. Modula-2 Module:     Semaphores
  2239. Syntax:                semaphore = FindSemaphore(name)
  2240. C:                    struct SignalSemaphore *FindSemaphore(char *)
  2241. Machine Language:     d0 = FindSemaphore(a1)
  2242. Modula-2:        FindSemaphore(name: STRPTR): SignalSemaphorePtr
  2243. Arguments:        name = NULL terminated string that specifies name of
  2244.             semaphore
  2245. Result:            semaphore = pointer to specified SignalSemaphore structure;
  2246.             NULL if unsuccessful
  2247. -------------------------  
  2248. FindTask
  2249. Description:         finds a task
  2250. Library:            exec.library
  2251. Offset:             -$0126 (-294)
  2252. Modula-2 Module:     Tasks
  2253. Syntax:                task = FindTask(name)
  2254. C:                    struct Task *FindTask(char *)
  2255. Machine Language:    d0 = FindTask(a1)
  2256. Modula-2:        FindTask(name: STRPTR): TaskPtr
  2257. Arguments:        name = NULL terminated string that specifies name of task
  2258. Result:            task = pointer to specified task; NULL if unsuccessful
  2259. -------------------------
  2260. FindToolType
  2261. Description:        finds value of a ToolType variable
  2262. Library:        icon.library
  2263. Offset:               -$0060 (-96)
  2264. Modula-2 Module:     Icon
  2265. Syntax:                value = FindToolType(toolTypeArray, typeName)
  2266. C:                    struct char *FindToolType(char *, char *)
  2267. Machine Language:     d0 = FindToolType(a0, a1)
  2268. Modula-2:        FindToolType(toolTypeArray: StrArrayPtr; typeName: STRPTR):
  2269.             ADDRESS
  2270. Arguments:        toolTypeArray = pointer to an array of strings containing tool
  2271.             types
  2272.             typeName = NULL terminated string that specifies tool type to
  2273.             find
  2274. Result:            value = pointer to string containing specified tool type; NULL if
  2275.             typeName not found in toolTypeArray
  2276. -------------------------
  2277. Flood
  2278. Description:    floods (fills) an area of a RastPort
  2279. Library:    graphics.library
  2280. Offset:       -$014A (-330)
  2281. Modula-2 Module: Pens
  2282. Syntax:        Flood(rastPort, mode, x, y)
  2283. C:            void Flood(struct RastPort *, long, long, long)
  2284. Machine Language: Flood(a1, d2, d0, d1)
  2285. Modula-2:        Flood(rastPort: RastPortPtr; mode: LONGCARD; x, y: INTEGER)  
  2286. Arguments:    rastPort = RastPort to fill
  2287.     mode = type of fill- 0 (fill pixels that are the same color as
  2288.     AOLPen) or 1 (fill pixels that are the same color as pixel at x,y)
  2289.     x = horizontal coordinate where fill will begin
  2290.     y = vertical coordinate where fill will begin
  2291.  
  2292. Result:            none
  2293. -------------------------
  2294. FlushCList
  2295. Description:        clears a character list
  2296. Library:        clist.library
  2297. Offset:            -$0030 (-48)
  2298. Modula-2 Module:    none
  2299. Syntax:            FlushCList(cList)
  2300. C:            void FlushCList(long)
  2301. Machine Language:    FlushCList(a0)
  2302. Modula-2:        not available
  2303. Arguments:        cList = CList header-as returned by AllocCList( )
  2304.             or StrToCL( )-used to manage character list to clear
  2305. Result:            none
  2306. -------------------------
  2307. Forbid
  2308. Description:        prevents task rescheduling
  2309. Library:        exec.library
  2310. Offset:            -$0084 (-132)
  2311. Modula-2 Module:    Interrupts
  2312. Syntax:            Forbid( )
  2313. C:            void Forbid(void)
  2314. Machine Language:    Forbid( )
  2315. Modula-2:        Forbid( )
  2316. Arguments:        none
  2317. Result:            none
  2318. -------------------------
  2319. fpa
  2320. Description:        converts a fast floating point number into an ASCII string
  2321. Library:        amiga.lib (linked library)
  2322. Modula-2 Module:    none
  2323. Syntax:            exp = fpa(fnum, string)
  2324. C:            long fpa(float, char *)
  2325. Machine Language:    pea string 
  2326.             move.l fnum,-(sp)
  2327.             jsr _fpa ;exp returned in d0 and string equals fnum 
  2328.             addq.l #8,sp
  2329. Modula-2:        not available
  2330. Arguments:        fnum = floating point number to convert
  2331.             string = address of string to receive ASCII equivalent of fnum
  2332.             argument
  2333. Result:            exp = integer exponent of fnum
  2334. -------------------------
  2335. fpbcd
  2336. Description:        converts a fast floating point number into BCD format
  2337. Library:        amiga.lib (linked library)
  2338. Modula-2 Module:    none
  2339. Syntax:            fpbcd(fnum, string)
  2340. C:            void fpbcd(float, char *)
  2341. Machine Language:    pea string
  2342.             move.l fnum,-(sp)
  2343.             jsr _fpbcd ;BCD equivalent of fnum returned in string
  2344.             addq.l #8,sp
  2345. Modula-2:        not available
  2346. Arguments:        fnum = floating point number to convert
  2347.             string = address of five-byte string to receive BCD equivalent of
  2348.             fnum argument
  2349. Result:            string argument receives the BCD equivalent of fnum argument
  2350. -------------------------
  2351. FreeBoardMem
  2352. Description:        frees expansion board memory (opposite of AllocBoardMem( )
  2353. Library:        expansion.library
  2354. Offset:            -$004E (-78)
  2355. Modula-2 Module:    Expansion
  2356. Syntax:            FreeBoardMem(startSlot, slotSpec)
  2357. C:            void FreeBoardMem(long, long)
  2358. Machine Language:    d0 = FreeBoardMem(d0, d1)
  2359. Modula-2:        FreeBoardMem(startslot, slotSpeC: INTEGER)
  2360. Arguments:        startSlot = slot number as returned by AllocBoardMem( )
  2361.             slotSpec = number of slots to free
  2362. Result:            none
  2363. -------------------------
  2364. Modula-2:        FreeMem(memoryBlock: ADDRESS: byteSize: LONGCARD)
  2365. Arguments:        memoryBlock = pointer to memory block to free
  2366.             byteSize = size of block in bytes
  2367. Result:            none
  2368. -------------------------  
  2369. FreeCList
  2370. Description:        releases character list descriptor and any resources it uses
  2371. Library:            clist.library
  2372. Offset:            -$002A (-42)
  2373. Modula-2 Module:    none
  2374. Syntax:            FreeCList(cList)
  2375. C:            void FreeCList(long)
  2376. Machine Language:    FreeCList(a0)
  2377. Modula-2:        not available
  2378. Arguments:        cList = descriptor of character list to free
  2379. Result:            none
  2380. -------------------------
  2381. FreeColorMap
  2382. Description:        returns memory used by a ColorMap structure
  2383. Library:        graphics.library
  2384. Offset:            -$0240 (-576)
  2385. Modula-2 Module:    Views
  2386. Syntax:            FreeColorMap(colorMap)
  2387. C:            void FreeColorMap(struct ColorMap *)
  2388. Machine Language:    FreeColorMap(a0)
  2389. Modula-2:        FreeColorMap(colorMap: ColorMapPtr)
  2390. Arguments:        colorMap = ColorMap structure to free
  2391. Result:            none
  2392. -------------------------
  2393. FreeConfigDev
  2394. Description:        frees a ConfigDev structure
  2395. Library:        expansion.library
  2396. Offset:            -$0054 (-84)
  2397. Modula-2 Module:    ConfigVars
  2398. Syntax:            FreeConfigDev(configDev)
  2399. C:            void FreeConfigDev(struct ConfigDev *)
  2400. Machine Language:    FreeConfigDev(a0)
  2401. Modula-2:           FreeConfigDev(configDev: ConfigDevPtr)
  2402. Arguments:             configDev = ConfigDev structure as returned by AllocConfigDev( )
  2403. Result:            none
  2404. -------------------------  
  2405. FreeCopList
  2406. Description:        returns memory allocated for an intermediate copper list
  2407. Library:            graphics.library
  2408. Offset:            -$0222 (-546)
  2409. Modula-2 Module:    Copper
  2410. Syntax:            FreeCopList(copList)
  2411. C:            void FreeCopList(struct CopList *)
  2412. Machine Language:    FreeCopList(a0)
  2413. Modula-2:        FreeCopList(copList: CopListPtr)
  2414. Arguments:        copList = CopList structure to free
  2415. Result:            none
  2416. -------------------------
  2417. FreeCprList
  2418. Description:        returns memory allocated for a hardware copper list
  2419. Library:        graphics.library
  2420. Offset:            -$0234 (-564)
  2421. Modula-2 Module:    Copper
  2422. Syntax:            FreeCprList(cprlist)
  2423. C:            void FreeCprList(struct cprlist *)
  2424. Machine Language:    FreeCprList(a0)
  2425. Modula-2:        FreeCprList(cprlist: cprlistPtr)
  2426. Arguments:        cprlist = cprlist structure to free
  2427. Result:            none
  2428. -------------------------
  2429. FreeDiskObject
  2430. Description:        frees memory allocated for a Workbench disk object
  2431. Library:        icon.library
  2432. Offset:            -$005A (-90)
  2433. Modula-2 Module:    Icon
  2434. Syntax:            FreeDiskObject(diskObj)
  2435. C:            void FreeDiskObject(struct DiskObject *)
  2436. Machine Language:    FreeDiskObject(a0)
  2437. Modula-2:        FreeDiskObject(diskObj: DiskObjectPtr)
  2438. Arguments:        diskObj = DiskObject structure to free
  2439. Result:            none
  2440. -------------------------  
  2441. FreeEntry
  2442. Description:        frees many regions of memory
  2443. Library:        exec.library
  2444. Offset:            -$00E4 (-228)
  2445. Modula-2 Module:    Memory
  2446. Syntax:            FreeEntry(memList)
  2447. C:            void FreeEntry(struct MemList *)
  2448. Machine Language:    FreeEntry(a0)
  2449. Modula-2:        FreeEntry(memList: MemListPtr)
  2450. Arguments:        memList = MemList structure
  2451. Result:            none
  2452. -------------------------
  2453. FreeExpansionMem
  2454. Description:        frees expansion memory
  2455. Library:        expansion.library
  2456. Offset:            -$005A (-90)
  2457. Modula-2 Module:    Expansion
  2458. Syntax:            FreeExpansionMem(startSlot, numSlots)
  2459. C:            void FreeExpansionMem(long, long)
  2460. Machine Language:    FreeExpansionMem(d0, d1)
  2461. Modula-2:        FreeExpansionMem(startSlot, numSlots: INTEGER)
  2462. Arguments:        startSlot = slot number as returned by AllocExpansionMem( )
  2463.             slotSpec = number of slots to free
  2464. Result:            none
  2465. -------------------------
  2466. FreeFreeList
  2467. Description:        frees all memory in a free list
  2468. Library:        icon.library
  2469. Offset:            -$0036 (-54)
  2470. Modula-2 Module:    Icon
  2471. Syntax:            FreeFreeList(freeList)
  2472. C:            void FreeFreeList(struct FreeList *)
  2473. Machine Language:    FreeFreeList(a0)
  2474. Modula-2:        FreeFreeList(freeList: FreeListPtr)
  2475. Arguments:        memList = FreeList structure
  2476. Result:            none
  2477. -------------------------
  2478. FreeGBuffers
  2479. Description:        frees memory allocated by GetGBuffers( )
  2480. Library:        graphics.library
  2481. Offset:            -$0258 (-600)
  2482. Modula-2 Module:    Gels
  2483. Syntax:            FreeGBuffers(animOb, rastPort, dBuffer)
  2484. C:            void FreeGBuffers(struct AnimOb *, struct RastPort *, long)
  2485. Machine Language:    FreeGBuffers(a0, a1, d0)
  2486. Modula-2:        FreeGBuffers(animOb: AnimObPtr; rastPort: RastPortPtr; dBuffer:
  2487.             BOOLEAN)
  2488. Arguments:        animOb = AnimOb structure
  2489.             rastPort = Rastport structure
  2490.             dBuffer = double-buffer flag-TRUE for double-buffering
  2491. Result:            none
  2492. -------------------------
  2493. FreeMem
  2494. Description:        frees memory allocated by GetGBuffers( )
  2495. Library:        exec.library
  2496. Offset:            -$00D2 (-210)
  2497. Modula-2 Module:    Memory
  2498. Syntax:            FreeMem(memoryBlock, byteSize)
  2499. C:            void FreeMem(void *, long)
  2500. Machine Language:    FreeMem(a1, d0)
  2501. Modula-2:        FreeMem(memoryBlock: ADDRESS: byteSize: LONGCARD)
  2502. Arguments:        memoryBlock = pointer to memory block to free
  2503.             byteSize = size of block in bytes
  2504. Result:            none
  2505. -------------------------
  2506. FreeRaster
  2507. Description:        frees memory allocated by AllocRaster( )
  2508. Library:        graphics.library
  2509. Offset:            -$01F2 (-498)
  2510. Modula-2 Module:    Rasters
  2511. Syntax:            FreeRaster(p, width, height)
  2512. C:            void FreeRaster(PLANEPTR, long, long)
  2513. Machine Language:    FreeRaster(a0, d0, d1)
  2514. Modula-2:        FreeRaster(p: PlanePtr; width, height: CARDINAL)
  2515. Arguments:        p = memory block returned by AllocRaster( )
  2516.         width = width of bitplanes in pixels
  2517.         height = height of bitplanes in pixels
  2518. Result:            none
  2519. -------------------------  
  2520. FreeRemember
  2521. Description:        frees memory allocated by AllocRemember( )
  2522. Library:        intuition.library
  2523. Offset:            -$0198 (-408)
  2524. Modula-2 Module:    Intuition
  2525. Syntax:            FreeRemember(rememberKey, reallyForget)
  2526. C:            void FreeRemember(struct Remember *, long)
  2527. Machine Language:    FreeRemember(a0, d0)
  2528. Modula-2:        FreeRemember(rememberKey: RememberPrt; reallyForget:
  2529.             BOOLEAN)
  2530. Arguments:        rememberKey = address of pointer to Remember structure
  2531.             reallyForget = TRUE to free memory and link nodes; FALSE to
  2532.             free only link nodes
  2533. Result:            none
  2534. -------------------------
  2535. FreeSignal
  2536. Description:        frees a signal bit
  2537. Library:        exec.library
  2538. Offset:            -$0150 (-336)
  2539. Modula-2 Module:    Tasks
  2540. Syntax:            FreeSignal(signalNum)
  2541. C:            void FreeSignal(long)
  2542. Machine Language:    FreeSignal(d0)
  2543. Modula-2:        FreeSignal(signalNum: SIGNAL)
  2544. Arguments:        signalNum = signal number to free (0-31)
  2545. Result:            none
  2546. -------------------------
  2547. FreeSprite
  2548. Description:        makes sprite available for others to use
  2549. Library:        graphics.library
  2550. Offset:            -$019E (-414)
  2551. Modula-2 Module:    Sprites
  2552. Syntax:            FreeSprite(pick)
  2553. C:            void FreeSprite(long)
  2554. Machine Language:    FreeSprite(d0)
  2555. Modula-2:        FreeSprite(pick: INTEGER)
  2556. Arguments:        pick = number of sprite to free (0-7)
  2557. Result:            none
  2558. -------------------------
  2559. FreeSysRequest
  2560. Description:        frees memory allocated by BuildSysRequest( )
  2561. Library:        intuition.library
  2562. Offset:            -$0174 (-372)
  2563. Modula-2 Module:    Intuition
  2564. Syntax:            FreeSysRequest(window)
  2565. C:            void FreeSysRequest(struct Window *)
  2566. Machine Language:    FreeSysRequest(a0)
  2567. Modula-2:        FreeSysRequest(window: WindowPtr)
  2568. Arguments:        window = Window structure as returned by BuildSysRequest( )
  2569. Result:            none
  2570. -------------------------
  2571. FreeTrap
  2572. Description:        frees a processor trap
  2573. Library:        exec.library
  2574. Offset:            -$015C (-348)
  2575. Modula-2 Module:    Tasks
  2576. Syntax:            FreeTrap(trapNum)
  2577. C:            void FreeTrap(long)
  2578. Machine Language:    FreeTrap(d0)
  2579. Modula-2:        FreeTrap(trapNum: TRAP)
  2580. Arguments:        trapNum = trap number to free (0-15)
  2581. Result:            none
  2582. -------------------------
  2583. FreeVPortCoplists
  2584. Description:        frees all intermediate copper lists and their headers from a
  2585.             ViewPort
  2586. Library:        graphics.library
  2587. Offset:            -$021C (-540)
  2588. Modula-2 Module:    Views
  2589. Syntax:            FreeVPortCopLists(viewPort)
  2590. C:            void FreeVPortCopLists(struct ViewPort *)
  2591. Machine Language:    FreeVPortCopLists(a0)
  2592. Modula-2:        FreeVPortCopLists(viewPort: ViewPortPtr)
  2593. Arguments:        viewPort = ViewPort structure containing copper lists
  2594. Result:            none
  2595. -------------------------  
  2596. FreeWBObject
  2597. Description:        frees memory allocated for a Workbench object
  2598. Library:        icon.library
  2599. Offset:            -$003C (-60)
  2600. Modula-2 Module:    none
  2601. Syntax:            FreeWBObject(object)
  2602. C:            void FreeWBObject(struct WBObject *)
  2603. Machine Language:    FreeWBObject(a0)
  2604. Modula-2:        not available
  2605. Arguments:        object = WBObject structure to free
  2606. Result:            none
  2607. --------------------------
  2608. GetCC
  2609. Description:        gets 68000/68010 condition codes
  2610. Library:        exec.library
  2611. Offset:            -$0210 (-528)
  2612. Modula-2 Module:    Exec
  2613. Syntax:            condition = GetCC( )
  2614. C:            long GetCC(void)
  2615. Machine Language:    d0 = GetCC( )
  2616. Modula-2:        GetCC( ): BITSET
  2617. Arguments:        none
  2618. Result:            condition = 68000/68010 condition code
  2619. -------------------------
  2620. GetCLBuf
  2621. Description:        converts character list into contiguous data
  2622. Library:        clist.library
  2623. Offset:            -$0072 (-114)
  2624. Modula-2 Module:    none
  2625. Syntax:            length = GetCLBuf(cList, buffer, maxLength)
  2626. C:            long GetCLBuf(long, char *, long)
  2627. Machine Language:    d0 = GetCLBuf(a0, a1, d1)
  2628. Modula-2:        not available
  2629. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  2630.             StrToCL( )
  2631.             buffer = buffer to hold data
  2632.             maxLength = maximum size of buffer in bytes
  2633. Result:            length = number of bytes copied into buffer
  2634. -------------------------  
  2635. GetCLChar
  2636. Description:        gets a byte from the beginning of a character list
  2637. Library:        clist.library
  2638. Offset:            -$0042 (-66)
  2639. Modula-2 Module:    none
  2640. Syntax:            byte = GetCLChar(cList)
  2641. C:            long GetCLChar(long)
  2642. Machine Language:    d0 = GetCLChar(a0)
  2643. Modula-2:        not available
  2644. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  2645.             StrToCL( )
  2646. Result:            byte = byte from beginning of character list; -1 if no data
  2647. -------------------------
  2648. GetCLWord
  2649. Description:        gets a word from the beginning of a character list
  2650. Library:        clist.library
  2651. Offset:            -$005A (-90)
  2652. Modula-2 Module:    none
  2653. Syntax:            word = GetCLWord(cList)
  2654. C:            long GetCLWord(long)
  2655. Machine Language:    d0 = GetCLWord(a0)
  2656. Modula-2:        not available
  2657. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  2658.             StrToCL( )
  2659. Result:            word = word from beginning of character list; -1 if no data
  2660. -------------------------
  2661. GetColorMap
  2662. Description:        allocates and initializes a ColorMap structure
  2663. Library:        graphics.library
  2664. Offset:            -$023A (-570)
  2665. Modula-2 Module:    Views
  2666. Syntax:            colorMap = GetColorMap(entries)
  2667. C:            struct ColorMap *GetColorMap(long)
  2668. Machine Language:    d0 = GetColorMap(d0)
  2669. Modula-2:        GetColorMap(colorMap: LONGINT): ColorMapPtr
  2670. Arguments:        entries = number of entries for this color map
  2671. Result:            colorMap = pointer to ColorMap structure; O if unsuccessful
  2672. -------------------------  
  2673. GetCurrentBinding
  2674. Description:        sets static board configuration area
  2675. Library:        expansion.library
  2676. Offset:            -$008A (-138)
  2677. Modula-2 Module:    none
  2678. Syntax:            actual = GetCurrentBinding(currentBinding, size)
  2679. C:            long GetCurrentBinding(long, long)
  2680. Machine Language:    d0 = GetCurrentBinding(a0, d0)
  2681. Modula-2:        not available
  2682. Arguments:        currentBinding = CurrentBinding structure
  2683.             size = size of user's BindDriver structure
  2684. Result:            actual = actual size of the CurrentBinding structure
  2685. -------------------------
  2686. GetDefPrefs
  2687. Description:        gets a copy of the default Preferences
  2688. Library:        intuition.library
  2689. Offset:            -$007E (-126)
  2690. Modula-2 Module:    Preferences
  2691. Syntax:            prefBuffer = GetDefPrefs(prefBuffer, size)
  2692. C:            struct Preferences *GetDefPrefs(struct Preferences *, long)
  2693. Machine Language:    d0 = GetDefPrefs(a0, d0)
  2694. Modula-2:        GetDefPrefs(prefBuffer: ADDRESS; size: INTEGER): ADDRESS
  2695. Arguments:        prefBuffer = buffer to receive copy of default Preferences
  2696.             size = size of buffer in bytes
  2697. Result:            prefBuffer = pointer to your buffer
  2698. -------------------------
  2699. GetDiskObject
  2700. Description:        reads a Workbench DiskObject (.info file) from disk
  2701. Library:        icon.library
  2702. Offset:            -$004E (-78)
  2703. Modula-2 Module:    Icon
  2704. Syntax:            diskObj = GetDiskObject(name)
  2705. C:            struct DiskObject *GetDiskObject(char *)
  2706. Machine Language:    d0 = GetDiskObject(a0)
  2707. Modula-2:        GetDiskObject(name: STRPTR): DiskObjectPtr
  2708. Arguments:        name = name of Workbench object (.info file)
  2709. Result:            diskObj = pointer to DiskObject structure; 0 if unsuccessful
  2710. -------------------------  
  2711. GetGBuffers
  2712. Description:        attempts to allocate all buffers of an enter AnimOb
  2713. Library:        graphics.library
  2714. Offset:            -$00A8 (-168)
  2715. Modula-2 Module:    Gels
  2716. Syntax:            success = GetGBuffers(animOb, rastPort, dBuffer)
  2717. C:            long GetGBuffers(struct AnimOb *, struct RastPort *, long)
  2718. Machine Language:    d0 = GetGBuffers(a0, a1, d0)
  2719. Modula-2:        GetGBuffers(animOb: AnimObPtr; rastPort: RastPortPtr; dBuffer:
  2720.             BOOLEAN): BOOLEAN
  2721. Arguments:        animOb = AnimOb structure
  2722.             rastPort = Rastport structure
  2723.             dBuffer = double-buffer flag-TRUE for double-buffering
  2724. Result:            success = TRUE if successful; FALSE if unsuccessful
  2725. -------------------------
  2726. GetIcon
  2727. Description:        reads a DiskObject structure from disk
  2728. Library:        icon.library
  2729. Offset:            -$002A (-42)
  2730. Modula-2 Module:    none
  2731. Syntax:            status = GetIcon(name, icon, free)
  2732. C:            long GetIcon(char *, struct DiskObject *, struct FreeList *)
  2733. Machine Language:    d0 = GetIcon(a0, a1, a2)
  2734. Modula-2:        not available
  2735. Arguments:        name = name of icon (.info file)
  2736.             icon = DiskObject structure
  2737.             free = FreeList structure
  2738. Result:            status = nonzero if successful
  2739. -------------------------
  2740. GetMsg
  2741. Description:        gets next message from a message port
  2742. Library:        exec.library
  2743. Offset:            -$0174 (-372)
  2744. Modula-2 Module:    Ports
  2745. Syntax:            message = GetMsg(port)
  2746. C:            struct Message *GetMsg(struct MsgPort *)
  2747. Machine Language:    d0 = GetMsg(a0)
  2748. Modula-2:        GetMsg(port: MsgPortPtr): ADDRESS
  2749. Arguments:        port = receiving message port
  2750. Result:            message = pointer to first message; NULL if no message
  2751. -------------------------
  2752. GetPrefs
  2753. Description:        gets Preferences' current settings
  2754. Library:        intuition.library
  2755. Offset:            -$0084 (-132)
  2756. Modula-2 Module:    Preferences
  2757. Syntax:            prefBuffer = GetDefPrefs(prefBuffer, size)
  2758. C:            struct Preferences *GetDefPrefs(struct Preferences *, long)
  2759. Machine Language:    d0 = GetDefPrefs(a0, d0)
  2760. Modula-2:        GetDefPrefs(prefBuffer: ADDRESS; size: INTEGER): ADDRESS
  2761. Arguments:        prefBuffer = buffer to receive copy of Preferences
  2762.             size = size of buffer in bytes
  2763. Result:            prefBuffer = pointer to your buffer
  2764. -------------------------
  2765. GetRGB4
  2766. Description:        gets the value of an entry in a ColorMap structure
  2767. Library:        graphics.library
  2768. Offset:            -$0246 (-582)
  2769. Modula-2 Module:    Views
  2770. Syntax:            value = GetRGB4(colorMap, entry)
  2771. C:            long GetRGB4(struct ColorMap *, long)
  2772. Machine Language:    d0 = GetRGB4(a0, d0)
  2773. Modula-2:        GetRGB4(colorMap: ColorMapPtr; entry: LONGINT): INTEGER
  2774. Arguments:        colorMap = ColorMap structure
  2775.             entry = index into color table, specifying desired entry
  2776. Result:            value = two-byte, right-justified RGB value with four bits per
  2777.             color-red, green, blue; -1 if no valid entry
  2778. -------------------------
  2779. GetSereenData
  2780. Description:        copies all or part of a Screen structure into buffer; opens specifled
  2781.             screen if not already open
  2782. Library:        intuition.library
  2783. Offset:            -$01AA (-426)
  2784. Modula-2 Module:    Intuition
  2785. Syntax:            success = GetScreenData(buffer, size, type, screen)
  2786. C:            long GetScreenData(char *, long, long, struct Screen *)
  2787. Machine Language:    d0 = GetScreenData(a0, d0, d1, a1)
  2788. Modula-2:        GetScreenData(buffer: ADDRESS; size: CARDINAL; type:
  2789.             ScreenFlagSet; screen: ScreenPtr): BOOLEAN
  2790. Arguments:        buffer = buffer in which data will be placed
  2791.             size = size of buffer in bytes
  2792.             type = screen type-CUSTOMSCREEN, WORKBENCHSCREEN
  2793.             screen = custom Screen structure; ignored if type argument
  2794.             equals WORKBENCHSCREEN
  2795.  
  2796. Result:            success = TRUE if successful; FALSE if screen not available and
  2797.             could not be opened
  2798. -------------------------
  2799. GetSprite
  2800. Description:        allocates hardware sprite for simple sprite manager
  2801. Library:        graphics.library
  2802. Offset:            -$0198 (-408)
  2803. Modula-2 Module:    Sprites
  2804. Syntax:            spriteNumber = GetSprite(sprite, pick)
  2805. C:            long GetSprite(struct SimpleSprite *, long)
  2806. Machine Language:    d0 = GetSprite(a0, d0)
  2807. Modula-2:        GetSprite(sprite: SimpleSpritePtr; pick: INTEGER): INTEGER
  2808. Arguments:        sprite = SimpleSprite structure
  2809.             pick = number of desired sprite (0-7); -1 for next available
  2810.             sprite
  2811. Result:            spriteNumber = number of sprite allocated; -1 if sprite
  2812.             unavailable
  2813. -------------------------
  2814. GetWBObject
  2815. Description:        reads in a Workbench object from disk
  2816. Library:        icon.library
  2817. Offset:            -$001E (-30)
  2818. Modula-2 Module:    none
  2819. Syntax:            object = GetWBObject(name)
  2820. C:            struct WBObject *GetWBObject(char *)
  2821. Machine Language:    d0 = GetWBObject(a0)
  2822. Modula-2:        not available
  2823. Arguments:        name = NULL terminated string that specifies name of Work-
  2824.             bench object
  2825. Result:            object = pointer to Workbench object; 0 if unsuccessful
  2826. ------------------------- 
  2827. IEEEDPAbs
  2828. Description:        obtains the absolute value of an IEEE double-precision floating-
  2829.             point number
  2830. Library:        mathieeedoubbas.library
  2831. Offset:            -$0036 (-54)
  2832. Modula-2 Module:    none
  2833. Syntax:            fnum1 = IEEEDPAbs(fnum2)
  2834. C:            double IEEEDPAbs(double)
  2835. Machine Language:    d0/d1 = IEEEDPAbs(d0/d1)
  2836. Modula-2:        not available
  2837. Arguments:        fnum2 = IEEE double-precision floating-point number
  2838. Result:            fnum1 = absolute value of fnum2 in IEEE double-precision
  2839.             floating-point format
  2840. -------------------------
  2841. IEEEDPAcos
  2842. Description:        obtains the arccosine of an IEEE double-precision floating-point
  2843.             number
  2844. Library:        mathieeedoubtrans.library
  2845. Offset:            -$0078 (-120)
  2846. Modula-2 Module:    none
  2847. Syntax:            fnum1 = IEEEDPAcos(fnum2)
  2848. C:            double IEEEDPAcos(double)
  2849. Machine Language:    d0/d1 = IEEEDPAcos(d0/d1)
  2850. Modula-2:        not available
  2851. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  2852.             ing the cosine of an angle
  2853. Result:            fnum1 = IEEE double-precision floating-point value of fnum2 an-
  2854.             gle in radians
  2855. -------------------------
  2856. IEEEDPAdd
  2857. Description:        adds two IEEE double-precision floating-point numbers
  2858. Library:        mathieeedoubbas.library
  2859. Offset:            -$0042 (-66)
  2860. Modula-2 Module:    none
  2861. Syntax:            fnum1 = IEEEDPAdd(fnum2, fnum3)
  2862. C:            double IEEEDPAdd(double, d0uble)
  2863. Machine Language:    d0/d1 = IEEEDPAdd(d0/d1, d2/d3)
  2864. Modula-2:        not available
  2865. Arguments:        fnum2 = IEEE double-precision floating-point number
  2866.             fnum3 = IEEE double-precision floating-point number
  2867. Result:            fnum1 = fnum2 plus fnum3 in IEEE double-precision floating-
  2868.             point format
  2869. -------------------------
  2870. IEEEDPAsin
  2871. Description:        obtains the arcsine of an IEEE double-precision floating-point
  2872.             number
  2873. Library:        mathieeedoubtrans.library
  2874. Offset:            -$0072 (-114)
  2875. Modula-2 Module:    none
  2876. Syntax:            fnum2 = IEEEDPAsin(fnum2)
  2877. C:            double IEEEDPAsin(double)
  2878. Machine Language:    d0/d1 = IEEEDPAsin(d0/d1)
  2879. Modula-2:        not available
  2880. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  2881.             ing the sine of an angle
  2882. Result:            fnum1 = IEEE double-precision floating-point value of fnum2 an-
  2883.             gle in radians
  2884. -------------------------
  2885. IEEEDPAtan
  2886. Description:        obtains the arctangent of an IEEE double-precision floating-point
  2887.             number
  2888. Library:        mathieeedoubtrans.library
  2889. Offset:            -$0030 (-48)
  2890. Modula-2 Module:    none
  2891. Syntax:            fnum1 = IEEEDPAtan(fnum2)
  2892. C:            double IEEEDPAtan(double)
  2893. Machine Language:    d0/d1 = IEEEDPAtan(d0/d1)
  2894. Modula-2:        not available
  2895. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  2896.             ing the tangent of an angle
  2897. Result:            fnum1 = IEEE double-precision floating-point value of fnum2 an-
  2898.             gle in radians
  2899. -------------------------
  2900. IEEEDPCeil
  2901. Description:        obtains the Ceil function of an IEEE double-precision floating-
  2902.             point number (rounds it up)
  2903. Library:        mathieeedoubbas.library
  2904. Offset:            -$0060 (-96)
  2905. Modula-2 Module:    none
  2906. Syntax:            fnum1 = IEEEDPCeil(fnum2)
  2907. C:            double IEEEDPCeil(double)
  2908. Machine Language:    d0/d1 = IEEEDPCeil(d0/d1)
  2909. Modula-2:        not available
  2910. Arguments:        fnum2 = IEEE double-precision floating-point number
  2911. Result:            fnum1 = IEEE double-precision floating-point integer value that's
  2912.             closest to, but not less than the value of fnum2
  2913. -------------------------
  2914. IEEEDPCmp
  2915. Description:        compares two IEEE double-precision floating-point numbers
  2916. Library:        mathieeedoubbas.library
  2917. Offset:            -$002A (-42)
  2918. Modula-2 Module:    none
  2919. Syntax:            flag = IEEEDPCmp(fnum1, fnum2)
  2920. C:            long IEEEDPCmp(double, d0uble)
  2921. Machine Language:    d0 = IEEEDPCmp(d0/d1, d2/d3)
  2922. Modula-2:        not available
  2923. Arguments:        fnum1 = IEEE double-precision floating-point number
  2924.             fnum2 = IEEE double-precision floating-point number
  2925. Result:            flag = -1 if fnum1<fnum2; +1 if fnum1>fnum2; 0 if
  2926.             fnum1 = fnum2
  2927. -------------------------
  2928. IEEEDPCos
  2929. Description:        obtains the cosine of an IEEE double-precision floating-point
  2930.             number
  2931. Library:        mathieeedoubtrans.library
  2932. Offset:            -$002A (-42)
  2933. Modula-2 Module:    none
  2934. Syntax:            fnum1 = IEEEDPCos(fnum2)
  2935. C:            double IEEEDPCos(double)
  2936. Machine Language:    d0/d1 = IEEEDPCos(d0/d1)
  2937. Modula-2:        not available
  2938. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  2939.             ing an angle in radians
  2940. Result:            fnum1 = IEEE double-precision floating-point cosine of fnum2
  2941. -------------------------
  2942. IEEEDPCosh
  2943. Description:        obtains the hyperbolic cosine of an IEEE double-precision float-
  2944.             ing-point number
  2945. Library:        mathieeedoubtrans.library
  2946. Offset:            -$0042 (-66)
  2947. Modula-2 Module:    none
  2948. Syntax:            fnum1 = IEEEDPCosh(fnum2)
  2949. C:            double IEEEDPCosh(double)
  2950. Machine Language:    d0/d1 = IEEEDPCosh(d0/d1)
  2951. Modula-2:        not available
  2952. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  2953.             ing an angle in radians
  2954. Result:            fnum1 = IEEE double-precision floating-point hyperbolic cosine
  2955.             of fnum2
  2956. -------------------------
  2957. IEEEDPDiv
  2958. Description:        divides one IEEE double-precision floating-point number by
  2959.             another
  2960. Library:        mathieeedoubbas.library
  2961. Offset:            -$0054 (-84)
  2962. Modula-2 Module:    none
  2963. Syntax:            fnum1 = IEEEDPDiv(fnum2, fnum3)
  2964. C:            double IEEEDPDiv(double, d0uble)
  2965. Machine Language:    d0/d1 = IEEEDPDiv(d0/d1, d2/d3)
  2966. Modula-2:        not available
  2967. Arguments:        fnum2 = IEEE double-precision floating-point dividend
  2968.             fnum3 = IEEE double-precision floating-point divisor
  2969. Result:            fnum1 = IEEE double-precision floating-point format results of
  2970.             fnum2 divided by fnum3
  2971. -------------------------
  2972. IEEEDPExp
  2973. Description:        obtains the exponent of an IEEE double-precision floating-point
  2974.             number
  2975. Library:        mathieeedoubtrans.library
  2976. Offset:            -$004E (-78)
  2977. Modula-2 Module:    none
  2978. Syntax:            fnum1 = IEEEDPExp(fnum2)
  2979. C:            double IEEEDPExp(double)
  2980. Machine Language:    d0/d1 = IEEEDPExp(d0/d1)
  2981. Modula-2:        not available
  2982. Arguments:        fnum2 = IEEE double-precision floating-point number
  2983. Result:            fnum1 = IEEE double-precision floating-point value representing
  2984.             e raised to the power of fnum2
  2985. -------------------------
  2986. IEEEDPFieee
  2987. Description:        converts a IEEE single-precision floating-point number to an IEEE
  2988.             double-precision floating-point number
  2989. Library:        mathieeedoubtrans.library
  2990. Offset:            -$006C (-108)
  2991. Modula-2 Module:    none
  2992. Syntax:            fnum1 = IEEEDPFieee(fnum2)
  2993. C:            double IEEEDPFieee(float)
  2994. Machine Language:    d0/d1 = IEEEDPFieee(d0)
  2995. Modula-2:        not available
  2996. Arguments:        fnum2 = IEEE single-precision floating-point number
  2997. Result:            fnum1 = IEEE double-precision floating-point equivalent to
  2998.             fnum2
  2999. -------------------------
  3000. IEEEDPFix
  3001. Description:        converts an IEEE double-precision floating-point number to an
  3002.             integer
  3003. Library:        mathieeedoubbas.library
  3004. Offset:            -$001E (-30)
  3005. Modula-2 Module:    none
  3006. Syntax:            inum = IEEEDPFix(fnum)
  3007. C:            long IEEEDPFix(double)
  3008. Machine Language:    d0 = IEEEDPFix(d0/d1)
  3009. Modula-2:        not available
  3010. Arguments:        fnum = IEEE double-precision floating-point number
  3011. Result:            inum = integer equivalent to fnum
  3012. -------------------------
  3013. IEEEDPFloor
  3014. Description:        obtains the Floor function of an IEEE double-precision floating-
  3015.             point number (rounds it down)
  3016. Library:        mathieeedoubbas.library
  3017. Offset:            -$005A (-90)
  3018. Modula-2 Module:    none
  3019. Syntax:            fnum1 = IEEEDPFloor(fnum2)
  3020. C:            double IEEEDPFloor(double)
  3021. Machine Language:    d0/d1 = IEEEDPFloor(d0/d1)
  3022. Modula-2:        not available
  3023. Arguments:        fnum2 = IEEE double-precision floating-point number
  3024. Result:            fnum1 = IEEE double-precision floating-point integer value that's
  3025.             closest to, but not greater than the value of fnum2
  3026. -------------------------
  3027. IEEEDPFlt
  3028. Description:        converts an integer to an IEEE double-precision floating-point
  3029.             number
  3030. Library:        mathieeedoubbas.library
  3031. Offset:            -$0024 (-36)
  3032. Modula-2 Module:    none
  3033. Syntax:            fnum = IEEEDPFlt(inum)
  3034. C:            double IEEEDPFlt(long)
  3035. Machine Language:    d0/d1 = IEEEDPFlt(d0)
  3036. Modula-2:        not available
  3037. Arguments:        inum = signed integer to be converted
  3038. Result:            fnum = IEEE double-precision floating-point equivalent to inum
  3039. -------------------------
  3040. IEEEDPLog
  3041. Description:        obtains the natural logarithm of an IEEE double-precision floating-
  3042.             point number
  3043. Library:        mathieeedoubtrans.library
  3044. Offset:            -$0054 (-84)
  3045. Modula-2 Module:    none
  3046. Syntax:            fnum1 = IEEEDPLog(fnum2)
  3047. C:            double IEEEDPLog(double)
  3048. Machine Language:    d0/d1 = IEEEDPLog(d0/d1)
  3049. Modula-2:        not available
  3050. Arguments:        fnum2 = IEEE double-precision floating-point number
  3051. Result:                fnum1 = IEEE double-precision floating-point natural logarithm
  3052.             (base e) of fnum2
  3053. -------------------------
  3054. IEEEDPlog10
  3055. Description:        obtains the naparian logarithm (base 10) of an IEEE double-
  3056.             precision floating-point number
  3057. Library:        mathieeedoubtrans.library
  3058. Offset:            -$007E (-126)
  3059. Modula-2 Module:    none
  3060. Syntax:            fnum1 = IEEEDPLog10(fnum2)
  3061. C:            double IEEEDPLog10(double)
  3062. Machine Language:    d0/d1 = IEEEDPLog10(d0/d1)
  3063. Modula-2:        not available
  3064. Arguments:        fnum2 = IEEE double-precision floating-point number
  3065. Result:            fnum1 = IEEE double-precision floating-point naparian logarithm
  3066.             (base 10) of fnum2
  3067. -------------------------
  3068. IEEEDPMul
  3069. Description:        multiplies one IEEE double-precision floating-point number by
  3070.             another
  3071. Library:        mathieeedoubbas.library
  3072. Offset:            -$004E (-78)
  3073. Modula-2 Module:    none
  3074. Syntax:            fnum1 = IEEEDPMul(fnum2, fnum3)
  3075. C:            double IEEEDPMul(double, d0uble)
  3076. Machine Language:    d0/d1 = IEEEDPMul(d0/d1, d2/d3)
  3077. Modula-2:        not available
  3078. Arguments:        fnum2 = IEEE double-precision floating-point number
  3079.             fnum3 = IEEE double-precision floating-point number
  3080. Result:            fnum1 = product of fnum2 and fnum3 in IEEE double-precision
  3081.             floating-point format
  3082. -------------------------
  3083. IEEEDPNeg
  3084. Description:        negates the value of an IEEE double-precision floating-point number
  3085. Library:        mathieeedoubbas.library
  3086. Offset:            -$003C (-60)
  3087. Modula-2 Module:    none
  3088. Syntax:            fnum1 = IEEEDPNeg(fnum2)
  3089. C:            double IEEEDPNeg(double)
  3090. Machine Language:    d0/d1 = IEEEDPNeg(d0/d1)
  3091. Modula-2:        not available
  3092. Arguments:        fnum2 = IEEE double-precision floating-point number to negate
  3093. Result:            fnum1 = negative fnum2 in IEEE double-precision floating-point
  3094.             format
  3095. -------------------------
  3096. IEEEDPPow
  3097. Description:        obtains the exponentiation of two IEEE double-precision floating-
  3098.             point numbers
  3099. Library:        mathieeedoubtrans.library
  3100. Offset:            -$005A (-90)
  3101. Modula-2 Module:    none
  3102. Syntax:            fnum1 = IEEEDPPow(fnum2, fnum3)
  3103. C:            double IEEEDPPow(double, d0uble)
  3104. Machine Language:    d0/d1 = IEEEDPPow(d2/d3, d0/d1)
  3105. Modula-2:        not available
  3106. Arguments:        fnum2 = IEEE double-precision floating-point number
  3107.             fnum3 = IEEE double-precision floating-point number
  3108. Result:            fnum1 = IEEE double-precision floating-point value of fnum2
  3109.             raised to the power of fnum3
  3110. -------------------------
  3111. IEEEDPSin
  3112. Description:        obtains the sine of an IEEE double-precision floating-point
  3113.             number
  3114. Library:        mathieeedoubtrans.library
  3115. Offset:            -$0024 (-36)
  3116. Modula-2 Module:    none
  3117. Syntax:            fnum1 = IEEEDPSin(fnum2)
  3118. C:            double IEEEDPSin(double, d0uble)
  3119. Machine Language:    d0/d1 = IEEEDPSin(d0/d1)
  3120. Modula-2:        not available
  3121. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  3122.             ing an angle in radians
  3123. Result:            fnum1 = IEEE double-precision floating-point sine of fnum2
  3124. -------------------------
  3125. IEEEDPSincos
  3126. Description:        obtains the sine and cosine of an IEEE double-precision floating-
  3127.             point number
  3128. Library:        mathieeedoubtrans.library
  3129. Offset:            -$0036 (-54)
  3130. Modula-2 Module:    none
  3131. Syntax:            fnum1 = IEEEDPSincos(fnum2, fnum3)
  3132. C:            double IEEEDPSincos(double, d0uble *)
  3133. Machine Language:    d0/d1 = IEEEDPSincos(d0/d1, a0)
  3134. Modula-2:        not available
  3135. Arguments:        fnum2 = IEEE double-precision floating-point number
  3136.             fnum3 = pointer to an IEEE double-precision floating point num-
  3137.             ber to receive the cosine of fnum2
  3138. Result:            fnum1 = IEEE double-precision floating-point sine of fnum2 (co-
  3139.             sine is returned in fnum3)
  3140. -------------------------
  3141. IEEEDPSinh
  3142. Description:        obtains the hyperbolic sine of an IEEE double-precision floating-
  3143.             point number
  3144. Library:        mathieeedoubtrans.library
  3145. Offset:            -$003C (-60)
  3146. Modula-2 Module:    none
  3147. Syntax:            fnum1 = IEEEDPSinh(fnum2)
  3148. C:            double IEEEDPSinh(double, d0uble)
  3149. Machine Language:    d0/d1 = IEEEDPSinh(d0/d1)
  3150. Modula-2:        not available
  3151. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  3152.             ing an angle in radians
  3153. Result:            fnum1 = IEEE double-precision floating-point hyperbolic sine of
  3154.             fnum2
  3155. -------------------------
  3156. IEEEDPSqrt
  3157. Description:        obtains the square root of an IEEE double-precision floating-point
  3158.             number
  3159. Library:        mathieeedoubtrans.library
  3160. Offset:            -$0060 (-96)
  3161. Modula-2 Module:    none
  3162. Syntax:            fnum1 = IEEEDPSqrt(fnum2)
  3163. C:            double IEEEDPSqrt(double)
  3164. Machine Language:    d0/d1 = IEEEDPSqrt(d0/d1)
  3165. Modula-2:        not available
  3166. Arguments:        fnum2 = IEEE double-precision floating-point number
  3167. Result:            fnum1 = IEEE double-precision floating-point square root of
  3168.             fnum2
  3169. -------------------------
  3170. IEEEDPSub
  3171. Description:        subtracts one IEEE double-precision floating-point number from
  3172.             another
  3173. Library:        mathieeedoubbas.library
  3174. Offset:            -$0048 (-72)
  3175. Modula-2 Module:    none
  3176. Syntax:            fnum1 = IEEEDPSub(fnum2, fnum3)
  3177. C:            double IEEEDPSub(double, d0uble)
  3178. Machine Language:    d0/d1 = IEEEDPSub(d0/d1, d2/d3)
  3179. Modula-2:        not available
  3180. Arguments:        fnum2 = IEEE double-precision floating-point number
  3181.             fnum3 = IEEE double-precision floating-point number
  3182. Result:            fnum1 = fnum2 minus fnum3 in IEEE double-precision floating-
  3183.             point format
  3184. -------------------------
  3185. IEEEDPTan
  3186. Description:        obtains the tangent of an IEEE double-precision floating-point
  3187.             number
  3188. Library:        mathieeedoubtrans.library
  3189. Offset:            -$0030 (-48)
  3190. Modula-2 Module:    none
  3191. Syntax:            fnum1 = IEEEDPTan(fnum2)
  3192. C:            double IEEEDPTan(double, d0uble)
  3193. Machine Language:    d0/d1 = IEEEDPTan(d0/d1)
  3194. Modula-2:        not available
  3195. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  3196.             ing an angle in radians
  3197. Result:            fnum1 = IEEE double-precision floating-point tangent of fnum2
  3198. -------------------------
  3199. IEEEDPTanh
  3200. Description:        obtains the hyperbolic tangent of an IEEE double-precision
  3201.             floating-point number
  3202. Library:        mathieeedoubtrans.library
  3203. Offset:            -$0048 (-72)
  3204. Modula-2 Module:    none
  3205. Syntax:            fnum1 = IEEEDPTanh(fnum2)
  3206. C:            double IEEEDPTanh(double, d0uble)
  3207. Machine Language:    d0/d1 = IEEEDPTanh(d0/d1)
  3208. Modula-2:        not available
  3209. Arguments:        fnum2 = IEEE double-precision floating-point number represent-
  3210.             ing an angle in radians
  3211. Result:            fnum1 = IEEE double-precision floating-point hyperbolic tangent
  3212.             of fnum2
  3213. ------------------------- 
  3214. IEEEDPTIeee
  3215. Description:        converts an IEEE double-precision floating-point number to an
  3216.             IEEE single-precision floating-point number
  3217. Library:        mathieeedoubtrans.library
  3218. Offset:            -$0066 (-102)
  3219. Modula-2 Module:    none
  3220. Syntax:            fnum1 = IEEEDPTieee(fnum2)
  3221. C:            float IEEEDPTieee(double)
  3222. Machine Language:    d0 = IEEEDPTieee(d0/d1)
  3223. Modula-2:        not available
  3224. Arguments:        fnum2 = IEEE double-precision floating-point number
  3225. Result:            fnum1 = IEEE single-precision floating-point equivalent to fnum2
  3226. -------------------------
  3227. IEEEDPTst
  3228. Description:        compares an IEEE double-precision floating-point number with
  3229.             zero
  3230. Library:        mathieeedoubbas.library
  3231. Offset:            -$0030 (-48)
  3232. Modula-2 Module:    none
  3233. Syntax:            flag = IEEEDPTst(fnum)
  3234. C:            long IEEEDPTst(double)
  3235. Machine Language:    d0 = IEEEDPTst(d0/d1)
  3236. Modula-2:        not available
  3237. Arguments:        fnum = IEEE double-precision floating-point number
  3238. Result:            flag = -1 if fnum <0; +1 if fnum >0; 0 if fnum=0
  3239. -------------------------
  3240. IncrCLMark
  3241. Description:        increments character list mark to the next position
  3242. Library:        clist.library
  3243. Offset:            -$007E (-126)
  3244. Modula-2 Module:    none
  3245. Syntax:            error = IncrCLMark(cList)
  3246. C:            long IncrCLMark(long)
  3247. Machine Language:    d0 = IncrCLMark(a0)
  3248. Modula-2:              not available
  3249. Arguments:        cList = character list descriptor
  3250. Result:            error = 0 if successful; nonzero if next offset is not in the charac-
  3251.             ter list
  3252. -------------------------
  3253. Info
  3254. Description:        returns information about a disk or disk file
  3255. Library:        dos.library
  3256. Offset:            -$0072 (-114)
  3257. Modula-2 Module:    DOS
  3258. Syntax:            success = Info(lock, infoData)
  3259. C:                long Info(BPTR, struct InfoData *)
  3260. Machine Language:    d0 = Info(d1, d2)
  3261. Modula-2:        Info(lock: FileLock; infoData: InfoDataPtr): BOOLEAN
  3262. Arguments:        lock = BCPL pointer to a lock
  3263.             infoData = InfoData structure to be filled
  3264. Result:            success = TRUE if successful; FALSE if unsuccessful
  3265. -------------------------
  3266. InitArea
  3267. Description:        initializes vector collection matrix
  3268. Library:        graphics.library
  3269. Offset:            -$011A (-282)
  3270. Modula-2 Module:    Areas
  3271. Syntax:            InitArea(areaInfo, buffer, maxVectors)
  3272. C:                long InitArea(struct AreaInfo *, short *, long)
  3273. Machine Language:    InitArea(a0, a1, d0)
  3274. Modula-2:        InitArea(areaInfo: AreaInfoPtr; buffer: ADDRESS; maxVectors:
  3275.             INTEGER)
  3276. Arguments:        areaInfo = AreaInfo structure
  3277.             buffer = pointer to memory block where vectors will be stored-
  3278.             must start on word boundary and should be 5*maxVectors bytes
  3279.             long
  3280.             maxVectors = maximum number of vectors
  3281. Result:            none
  3282. -------------------------
  3283. InitBitMap
  3284. Description:        initializes a BitMap structure
  3285. Library:        graphics.library
  3286. Offset:            -$0186 (-390)
  3287. Modula-2 Module:    Graphics
  3288. Syntax:            InitBitMap(bitMap, depth, width, height)
  3289. C:            void InitBitMap(struct Bitmap *, long, long, long)
  3290. Machine Language:    InitBitMap(a0, d0, d1, d2)
  3291. Modula-2:        InitBitMap(bitMap: BitMapPtr; depth, width, height: INTEGER)
  3292. Arguments:        bitMap = BitMap structure
  3293.             depth = number of bit planes to be used
  3294.             width = width of each bit plane in bits
  3295.             height = height of each bit plane in lines
  3296. Result:            none
  3297. -------------------------
  3298. InitCLPool
  3299. Description:        initializes a character list pool
  3300. Library:        clist.library
  3301. Offset:            -$001E (-30)
  3302. Modula-2 Module:    none
  3303. Syntax:            error = InitCLPool(cLPool, size)
  3304. C:            long InitCLPool(long, long)
  3305. Machine Language:    d0 = InitCLPool(a0, d0)
  3306. Modula-2:        not available
  3307. Arguments:        cLPool = data area to be used as character list pool
  3308.             size = size of pool in bytes
  3309. Result:            error = 0 if successful; nonzero if pool size is too small
  3310. -------------------------
  3311. InitCode
  3312. Description:        initializes resident modules with a startup class value and version
  3313.             number
  3314. Library:        exec.library
  3315. Offset:            -$0048 (-72)
  3316. Modula-2 Module:     Resident
  3317. Syntax:            InitCode(startClass, version)
  3318. C:            void InitCode(long, long)
  3319. Machine Language:    InitCode(d0, d1)
  3320. Modula-2:        InitCode(startClass, version: LONGCARD)
  3321. Arguments:        startClass = startup class of resident module-COLDSTART,
  3322.             COOLSTART, or WARMSTART
  3323.             version = version number of resident module
  3324. Result:            none
  3325. -------------------------
  3326. InitGels
  3327. Description:        initializes a GEL list
  3328. Library:        graphics.library
  3329. Offset:            -$0078 (-120)
  3330. Modula-2 Module:    Gels
  3331. Syntax:            InitGels(head, tail, gelsInfo)
  3332. C:            void InitGels(struct VSprite *, struct VSprite *, struct GelsInfo *)
  3333. Machine Language:    InitGels(a0, a1, a2)
  3334. Modula-2:        InitGels(head, tail: VSpritePtr; gelsInfo: GelsInfoPtr)
  3335. Arguments:        head = VSprite structure to be used as head of GEL list
  3336.             tail = VSprite structure to be used as tail of GEL list
  3337.             gelsInfo = GelsInfo structure to be initialized
  3338. Result:            none
  3339. -------------------------
  3340. InitGMasks
  3341. Description:        initializes all masks of an AnimOb structure
  3342. Library:        graphics.library
  3343. Offset:            -$00AE (-174)
  3344. Modula-2 Module:    Gels
  3345. Syntax:            InitGMasks(animOb)
  3346. C:            void InitGMasks(struct AnimOb *)
  3347. Machine Language:    InitGMasks(a0)
  3348. Modula-2:        InitGMasks(animOb: AnimObPtr)
  3349. Arguments:        animOb = AnimOb structure containing masks to initialize
  3350. Result:            none
  3351. -------------------------
  3352. InitLayers
  3353. Description:        initializes a Layer_Info structure
  3354. Library:        layers.library
  3355. Offset:            -$001E (-30)
  3356. Modula-2 Module:    none
  3357. Syntax:            InitLayers(layerInfo)
  3358. C:            void InitLayers(struct Layer_Info *)
  3359. Machine Language:    InitLayers(a0)
  3360. Modula-2:        not available
  3361. Arguments:        layerInfo = Layer_Info structure to initialize
  3362. Result:            none
  3363. -------------------------
  3364. InitMasks
  3365. Description:        initializes the BorderLine and CollMask values used by a VSprite
  3366.             structure
  3367. Library:        graphics.library
  3368. Offset:            -$007E (-126)
  3369. Modula-2 Module:    Gels
  3370. Syntax:            InitMasks(vSprite)
  3371. C:            void InitMasks(struct VSprite *)
  3372. Machine Language:    InitMasks(a0)
  3373. Modula-2:        InitMasks(vSprite: VSpritePtr)
  3374. Arguments:        vSprite = VSprite structure containing BorderLine and CollMask
  3375.             values to initialize
  3376. Result:            none
  3377. -------------------------
  3378. InitRastPort
  3379. Description:        initializes a RastPort structure
  3380. Library:        graphics.library
  3381. Offset:            -$00C6 (-198)
  3382. Modula-2 Module:    Rasters
  3383. Syntax:            InitRastPort(rastPort)
  3384. C:            void InitRastPort(struct RastPort *)
  3385. Machine Language:    InitRastPort(a1)
  3386. Modula-2:        InitRastPort(rastPort: RastPortPtr)
  3387. Arguments:        rastPort = RastPort structure to initialize
  3388. Result:            none
  3389. -------------------------
  3390. InitRequester
  3391. Description:        initializes a Requester structure
  3392. Library:        intuition.library
  3393. Offset:            -$008A (-138)
  3394. Modula-2 Module:    Intuition
  3395. Syntax:            InitRequester(requester)
  3396. C:            void InitRequester(struct Requester *)
  3397. Machine Language:    InitRequester(a0)
  3398. Modula-2:        InitRequester(requester: RequesterPtr)
  3399. Arguments:        requester = Requester structure to initialize
  3400. Result:            none
  3401. -------------------------
  3402. InitResident
  3403. Description:        initializes a resident module
  3404. Library:        exec.library
  3405. Offset:            -$0066 (-102)
  3406. Modula-2 Module:    Resident
  3407. Syntax:            InitResident(resident, segList)
  3408. C:            void InitResident(struct Resident *, char *)
  3409.  
  3410. Machine Language:    InitResident(a1, d1)
  3411. Modula-2:        InitResident(resident: ResidentPtr; segList: ADDRESS)
  3412. Arguments:        resident = Resident structure representing resident module to
  3413.             initialize
  3414.             segList = a segment list
  3415. Result:            none
  3416. -------------------------
  3417. InitSemaphore
  3418. Description:        initializes a SignalSemaphore structure
  3419. Library:        exec.library
  3420. Offset:            -$022E (-558)
  3421. Modula-2 Module:    Semaphores
  3422. Syntax:            InitSemaphore(signalSemaphore)
  3423. C:            void InitSemaphore(struct SignalSemaphore *)
  3424. Machine Language:    InitSemaphore(a0)
  3425. Modula-2:        InitSemaphore(signalSemaphore: SignalSemaphorePtr)
  3426. Arguments:        signalSemaphore = SignalSemaphore structure to initialize
  3427. Result:            none
  3428. -------------------------
  3429. InitStruct
  3430. Description:        clears an area of memory following rules defined by a table
  3431. Library:        exec.library
  3432. Offset:            -$004E (-78)
  3433. Modula-2 Module:    Memory
  3434. Syntax:            InitStruct(initTable, memBlock, size)
  3435. C:            void InitStruct(char *, char *, long)
  3436. Machine Language:    InitStruct(a1, a2, d0)
  3437. Modula-2:        InitStruct(initTable, memBlock: ADDRESS; size: CARDINAL)
  3438. Arguments:        initTable = pointer to the commands and data used to initialize
  3439.             memory
  3440.             memBlock = pointer to memory to be initialized
  3441.             size = size of memory to clear before it is initialized with
  3442.             initTable; 0 for no initial clearing of memory
  3443. Result:            none
  3444. -------------------------
  3445. InitTmpRas
  3446. Description:        initializes chip RAM for use by area-fill, flood-fill, and text
  3447.             functions
  3448. Library:        graphics.library
  3449. Offset:            -$01D4 (-468)
  3450. Modula-2 Module:    Rasters
  3451. Syntax:            InitTmpRas(tmpRas, buffer, size)
  3452. C:            void InitTmpRas(struct TmpRas *, char *, long)
  3453. Machine Language:    InitTmpRas(a0, a1, d0)
  3454. Modula-2:        InitTmpRas(tmpRas: TmpRasPtr; buffer: PlanePtr; size:
  3455.             LONGCARD)
  3456. Arguments:        tmpRas = TmpRas structure to be linked into a RastPort
  3457.             buffer = pointer to chip RAM memory
  3458.             size = size of buffer in bytes
  3459. Result:            none
  3460. -------------------------
  3461. InitView
  3462. Description:        initializes a View structure
  3463. Library:        graphics.library
  3464. Offset:            -$0168 (-360)
  3465. Modula-2 Module:    Views
  3466. Syntax:            InitView(view)
  3467. C:            void InitView(struct View *)
  3468. Machine Language:    InitView(a1)
  3469. Modula-2:        InitView(view: ViewPtr)
  3470. Arguments:        view = View structure to initialize
  3471. Result:            none
  3472. -------------------------
  3473. InitVPort
  3474. Description:        initializes a ViewPort structure
  3475. Library:        graphics.library
  3476. Offset:            -$00CC (-204)
  3477. Modula-2 Module:    Views
  3478. Syntax:            InitVPort(viewPort)
  3479. C:            void InitVPort(struct ViewPort *)
  3480. Machine Language:    InitVPort(a0)
  3481. Modula-2:              InitVPort(viewPort: ViewPortPtr)
  3482. Arguments:        viewPort = ViewPort structure to initialize
  3483. Result:            none
  3484. -------------------------  
  3485. Input
  3486. Description:        gets the initial input file handle assigned to a program
  3487. Library:        dos.library
  3488. Offset:            -$0036 (-54)
  3489. Modula-2 Module:    DOS
  3490. Syntax:            file = Input( )
  3491. C:            BPTR Input(void)
  3492. Machine Language:    d0 = Input( )
  3493. Modula-2:        Input( ): FileHandle
  3494. Arguments:        none
  3495. Result:            file = BCPL pointer to a file handle
  3496. -------------------------
  3497. Insert
  3498. Description:        inserts a Node structure into a doubly-linked list
  3499. Library:        exec.library
  3500. Offset:            -$00EA (-234)
  3501. Modula-2 Module:    Lists
  3502. Syntax:            Insert(list, node, listNode)
  3503. C:            void Insert(struct List *, struct Node *, struct Node *)
  3504. Machine Language:    Insert(a0, a1, a2)
  3505. Modula-2:        Insert(list: ListPtr; node, listNode: NodePtr)
  3506. Arguments:        list = target List header
  3507.             node = Node structure to insert
  3508.             listNode = node after which to insert; NULL to insert at head
  3509. Result:            none
  3510. -------------------------
  3511. InstallClipRegion
  3512. Description:        installs a clip region into a layer
  3513. Library:        layers.library
  3514. Offset:            -$00AE (-174)
  3515. Modula-2 Module:    Layers
  3516. Syntax:            oldClipRegion = InstallClipRegion(layer, region)
  3517. C:            struct Region *InstallClipRegion(struct Layer *, struct Region *)
  3518. Machine Language:    d0 = InstallClipRegion(a0, a1)
  3519. Modula-2:        InstallClipRegion(layer: LayerPtr; region: RegionPtr): RegionPtr
  3520. Arguments:        layer = Layer structure to which region will be added
  3521.             region = Region structure to be added to layer
  3522. Result:            oldClipRegion = previous clip region that was installed; NULL if
  3523.             no previous clip region
  3524. ------------------------- 
  3525. IntuiTextLength
  3526. Description:        returns the pixel width of an IntuiText string
  3527. Library:        intuition.library
  3528. Offset:            -$014A (-330)
  3529. Modula-2 Module:    Intuition
  3530. Syntax:            length = IntuiTextLength(intuiText)
  3531. C:            long IntuiTextLength(struct IntuiText *)
  3532. Machine Language:    d0 = IntuiTextLength(a0)
  3533. Modula-2:        IntuiTextLength(intuiText: IntuiTextPtr): CARDINAL
  3534. Arguments:        intuiText = IntuiText structure
  3535. Result:            length = pixel width of text
  3536. -------------------------
  3537. Intuition
  3538. Description:        sets Intuition's main entry point, where input events arrive and
  3539.             are dispatched
  3540. Library:        intuition.library
  3541. Offset:            -$0024 (-36)
  3542. Modula-2 Module:    Intuition
  3543. Syntax:            Intuition(inputEvent)
  3544. C:            void Intuition(struct InputEvent *)
  3545. Machine Language:    Intuition(a0)
  3546. Modula-2:        Intuition(inputEvent: InputEventPtr)
  3547. Arguments:        inputEvent = first input event in a linked list of InputEvent
  3548.             structures
  3549. Result:            none
  3550. -------------------------
  3551. IoErr
  3552. Description:        gets extra information from the system
  3553. Library:        dos.library
  3554. Offset:            -$0084 (-132)
  3555. Modula-2 Module:    DOS
  3556. Syntax:            error = IoErr( )
  3557. C:            long IoErr(void)
  3558. Machine Language:    d0 = IoErr( )
  3559. Modula-2:        IoErr( ): LONGINT
  3560. Arguments:        none
  3561. Result:            error = error code or other error information
  3562. ------------------------- 
  3563. IsInteractive
  3564. Description:        finds out whether a file is connected to a virtual terminal
  3565. Library:        dos.library
  3566. Offset:            -$00D8 (-216)
  3567. Modula-2 Module:    DOS
  3568. Syntax:            status = IsInteractive(file)
  3569. C:            long IsInteractive(BPTR)
  3570. Machine Language:    d0 = IsInteractive(d1)
  3571. Modula-2:        IsInteractive(file: FileHandle): BOOLEAN
  3572. Arguments:        file = BCPL pointer to a file handle
  3573. Result:            status = TRUE if file is connected to a virtual terminal; FALSE if
  3574.             not
  3575. -------------------------
  3576. ItemAddress
  3577. Description:        returns address of specified MenuItem
  3578. Library:        intuition.library
  3579. Offset:            -$0090 (-144)
  3580. Modula-2 Module:    Intuition
  3581. Syntax:            address = ItemAddress(menuStrip, menuNumber)
  3582. C:            struct MenuItem *ItemAddress(struct Menu *, long)
  3583. Machine Language:    d0 = ItemAddress(a0, d0)
  3584. Modula-2:        ItemAddress(menuStrip: MenuPtr; menuNumber: CARDINAL):
  3585.             MenuItemPtr
  3586. Arguments:        menuStrip = first menu in your menu strip
  3587.             menuNumber = value with packed data that specifies the menu
  3588.             and item (and optionally subitem)
  3589. Result:            address = pointer to specified MenuItem; NULL if menuNumber
  3590.             equals NULL
  3591. -------------------------
  3592. ITEMNUM (macro)
  3593. Description:        extracts the menu item number from a value
  3594. C Include File:        include/intuition/intuition.h
  3595. ML Include File:    none
  3596. Modula-2 Module:    Intuition
  3597. Syntax:            itemNumber = ITEMNUM(menuValue)
  3598. C:            long ITEMNUM(long)
  3599. Machine Language:    not available
  3600. Modula-2:        ITEMNUM(menuValue: CARDINAL): CARDINAL
  3601. Arguments:        menuValue = 16-bit packed number representing the menu num-
  3602.             ber, item number, and subitem number
  3603. Result:            itemNumber = item number (0-63); equals NOITEM if no menu
  3604.             was selected
  3605. -------------------------
  3606. LoadRGB4
  3607. Description:        loads color register values from a data table
  3608. Library:        graphics.library
  3609. Offset:            -$00C0 (-192)
  3610. Modula-2 Module:    Views
  3611. Syntax:            LoadRGB4(viewPort, colormap, pens)
  3612. C:            void LoadRGB4(struct ViewPort *, short *, long)
  3613. Machine Language:    LoadRGB4(a0, a1, d0)
  3614. Modula-2:        LoadRGB4(viewPort: ViewPortPtr; colormap: ADDRESS; pens:
  3615.             INTEGER)
  3616. Arguments:        viewPort = ViewPort whose colors you want to change
  3617.             colormap = pointer to array of 16-bit color values, where the firs
  3618.             four bits are zero, the second contains red, the third green, and
  3619.             the fourth blue
  3620.             pens = number of consecutive color registers to load
  3621. Result:            none
  3622. -------------------------
  3623. LoadSeg
  3624. Description:        loads an AmigaDOS load module into memory
  3625. Library:        dos.library
  3626. Offset:            -$0096 (-150)
  3627. Modula-2 Module:    DOSLoader
  3628. Syntax:            segment = LoadSeg(name)
  3629. C:            BPTR LoadSeg(char *)
  3630. Machine Language:    d0 = LoadSeg(d1)
  3631. Modula-2:        LoadSeg(name: STRPTR): BPTR
  3632. Arguments:        name = NULL terminated string that specifies the filename of
  3633.             load module
  3634. Result:            segment = BCPL pointer to a segment; 0 if unsuccessful
  3635. -------------------------
  3636. LoadView
  3637. Description:        creates a display using a new copper list
  3638. Library:        graphics.library
  3639. Offset:            -$00DE (-222)
  3640. Modula-2 Module:    Views
  3641. Syntax:            LoadView(view)
  3642. C:            void LoadView(struct View *)
  3643. Machine Language:    LoadView(a1)
  3644. Modula-2:        LoadView(view: ViewPtr)
  3645. Arguments:        view = View structure with pointer to copper list
  3646. Result:            none
  3647. -------------------------
  3648. Lock
  3649. Description:        locks a directory or file
  3650. Library:        dos.library
  3651. Offset:            -$0054 (-84)
  3652. Modula-2 Module:    DOS
  3653. Syntax:            lock = Lock(name, accessMode)
  3654. C:            BPTR Lock(char *, long)
  3655. Machine Language:    d0 = Lock(d1, d2)
  3656. Modula-2:        Lock(name: STRPTR; accessMode: LONGINT): FileLock
  3657. Arguments:        name = NULL terminated string that specifies name of file or
  3658.             directory
  3659.             accessMode = type of lock-ACCESS_READ (shared) or
  3660.             ACCESS_WRITE (exclusive)
  3661. Result:            lock = BCPL pointer to a lock
  3662. -------------------------
  3663. LockIBase
  3664. Description:        locks IntuitionBase to keep other tasks (or the system) from
  3665.             changing it
  3666. Library:        intuition.library
  3667. Offset:            -$019E (-414)
  3668. Modula-2 Module:    IntuitionBase
  3669. Syntax:            lockValue = LockIBase(lockNumber)
  3670. C:            long LockIBase(long)
  3671. Machine Language:    d0 = LockIBase(d0)
  3672. Modula-2:        LockIBase(lockNumber: LONGCARD): LONGCARD
  3673. Arguments:        lockNumber = Intuition lock desired (should be zero)
  3674. Result:            lockValue = value to use to unlock IntuitionBase via
  3675.             UnlockIBase( )
  3676. -------------------------
  3677. LockLayer
  3678. Description:        locks a layer to protect it from graphics output
  3679. Library:        layers.library
  3680. Offset:            -$0060 (-96)
  3681. Modula-2 Module:    Layers
  3682. Syntax:            LockLayer(dummy, layer)
  3683. C:            void LockLayer(struct Layer_Info *, struct Layer *)
  3684. Machine Language:    LockLayer(a0, a1)
  3685. Modula-2:        LockLayer(layer: LayerPtr)
  3686. Arguments:        dummy = unused
  3687.             layer = Layer structure
  3688. Result:            none
  3689. -------------------------
  3690. LockLayerInfo
  3691. Description:        locks a Layer_Info structure to keep other tasks from changing it
  3692. Library:        layers.library
  3693. Offset:            -$0078 (-120)
  3694. Modula-2 Module:    Layers
  3695. Syntax:            LockLayerInfo(layerInfo)
  3696. C:            void LockLayerInfo(struct Layer_Info *)
  3697. Machine Language:    LockLayerInfo(a0, a1)
  3698. Modula-2:        LockLayerInfo(layerInfo: LayerInfoPtr)
  3699. Arguments:        layerInfo = Layerlnfo structure to lock
  3700. Result:            none
  3701. -------------------------
  3702. LockLayerRom
  3703. Description:        locks a Layer structure to keep other tasks from changing it
  3704. Library:        layers.library
  3705. Offset:            -$01B0 (-432)
  3706. Modula-2 Module:    Clip
  3707. Syntax:            LockLayerRom(layer)
  3708. C:            void LockLayerRom(struct Layer *)
  3709. Machine Language:    LockLayerRom(a5)
  3710. Modula-2:              LockLayerRom(layer: LayerPtr)
  3711. Arguments:        layer = Layer structure to lock
  3712. Result:            none
  3713. -------------------------
  3714. LockLayers
  3715. Description:        stops graphic output to all layers in a Layer_Info structure
  3716. Library:        layers.library
  3717. Offset:            -$006C (-108)
  3718. Modula-2 Module:    Layers
  3719. Syntax:            LockLayers(layerInfo)
  3720. C:                void LockLayers(struct Layer_Info *)
  3721. Machine Language:    LockLayers(a0)
  3722. Modula-2:        LockLayers(layerInfo: LayerInfoPtr)
  3723. Arguments:        layerlnfo = Layerlnfo structure with list of layers to lock
  3724. Result:            none
  3725. -------------------------
  3726. MakeDosNode
  3727. Description:        initializes the DeviceNode structure required to enter a DOS disk
  3728.             device into the system
  3729. Library:        expansion.library
  3730. Offset:            -$0090 (-144)
  3731. Modula-2 Module:    Expansion
  3732. Syntax:            deviceNode = MakeDosNode(parameterPacket)
  3733. C:                   struct DeviceNode *MakeDosNode(long *)
  3734. Machine Language:    d0 = MakeDosNode(a0)
  3735. Modula-2:        MakeDosNode(parameterPacket: ADDRESS): DeviceNodePtr
  3736. Arguments:        parameterPacket = array of long words containing the DOS han-
  3737.             dler name, exec device name, unit number (for OpenDevice( )),
  3738.             flags (for OpenDevice( )), number of long words used to describe
  3739.             the handler environment, and the file handler environment, in
  3740.             that order.
  3741. Result:            deviceNode = pointer to initialized DeviceNode structure; NULL
  3742.             if not enough memory
  3743. -------------------------
  3744. MakeFunctions
  3745. Description:        constructs a jump table of the type used by resources, libraries,
  3746.             and devices
  3747. Library:        exec.library
  3748. Offset:            -$005A (-90)
  3749. Modula-2 Module:    Libraries
  3750. Syntax:            size = MakeFunctions(destination, funcArray, funcDispBase)
  3751. C:            void MakeFunctions(char *, long *, long)
  3752. Machine Language:    d0 = MakeFunctions(a0, a1, a2)
  3753. Modula-2:        MakeFunctions(destination, funcArray, funcDispBase: ADDRESS):
  3754.             LONGCARD
  3755. Arguments:        destination = target address for function jump table
  3756.             funcArray = pointer to array of function pointers or
  3757.             displacements
  3758.             funcDispBase = pointer to base about which all function displace-
  3759.             ments are relative; 0 if functionArray contains absolute pointers
  3760. Result:            size = size of new table in bytes (Modula-2 only)
  3761. -------------------------
  3762. MakeLibrary
  3763. Description:        constructs a library vector and data area
  3764. Library:        exec.library
  3765. Offset:            -$0054 (-84)
  3766. Modula-2 Module:    Libraries
  3767. Syntax:            library = MakeLibrary(vectors, structure, init, dataSize, segList)
  3768. C:            struct Library *MakeLibrary(long *, char *, _fptr, long, char *)
  3769. Machine Language:    d0 = MakeLibrary(a0, a1, a2, d0, d1)
  3770. Modula-2:        MakeLibrary(vectors, structure: ADDRESS; init: MAKELIBPROC;
  3771.             dataSize: LONGCARD; segList: ADDRESS): LibraryPtr
  3772. Arguments:        vectors = pointer to an array of function displacements-if first
  3773.             word is -1 array contains relative word displacements; otherwise
  3774.             array contains absolute function pointers
  3775.             structure = pointer to an InitStruct data region; can be NULL
  3776.             init = entry point that will be called before adding the library;
  3777.             can be NULL
  3778.             dataSize = size of library data area, including the standard library
  3779.             node data
  3780.             segList = pointer to a memory segment list (used by DOS)
  3781. Result:            library = reference address of library
  3782. -------------------------
  3783. MakeScreen
  3784. Description:        executes an Intuition-integrated MakeVPort( ) of a custom screen
  3785. Library:        intuition.library
  3786. Offset:            -$017A (-378)
  3787. Modula-2 Module:    Intuition
  3788. Syntax:            MakeScreen(screen)
  3789. C:            void MakeScreen(struct Screen *)
  3790. Machine Language:    MakeScreen(a0)
  3791. Modula-2:        MakeScreen(screen: ScreenPtr)
  3792. Arguments:        screen = custom screen
  3793. Result:            none
  3794. -------------------------
  3795. MakeVPort
  3796. Description:        constructs intermediate copper list for a ViewPort
  3797. Library:        graphics.library
  3798. Offset:            -$00D8 (-216)
  3799. Modula-2 Module:    Views
  3800. Syntax:            MakeVPort(view, viewPort)
  3801. C:            void MakeVPort(struct View *, struct ViewPort *)
  3802. Machine Language:    MakeVPort(a0, a1)
  3803. Modula-2:        MakeVPort(view: ViewPtr; viewPort: ViewPortPtr)
  3804. Arguments:        view = View structure
  3805.             viewPort = ViewPort structure
  3806. Result:            none
  3807. -------------------------
  3808. MarkCList
  3809. Description:        marks a position in a character list
  3810. Library:        clist.library
  3811. Offset:            -$0078 (-120)
  3812. Modula-2 Module:    none
  3813. Syntax:            error = MarkCList(cList, offset)
  3814. C:            long MarkCList(long, long)
  3815. Machine Language:    d0 = MarkCList(a0, a1)
  3816. Modula-2:        not available
  3817. Arguments:        cList = CList descriptor
  3818.             offset = byte offset into character list of position to mark
  3819. Result:            error = 0 if successful; nonzero if offset not in character list
  3820. -------------------------
  3821. MatchToolValue
  3822. Description:        checks a tool type variable for a particular value
  3823. Library:        icon.library
  3824. Offset:            -$0066 (-102)
  3825. Modula-2 Module:    Icon
  3826. Syntax:            result = MatchToolValue(typeString, value)
  3827. C:            long MatchToolValue(char *, char *)
  3828. Machine Language:    d0 = MatchToolValue(a0, a1)
  3829. Modula-2:        MatchToolValue(typeString, value: STRPTR): BOOLEAN
  3830. Arguments:        typeString = a ToolType value, as returned by FindToolType(
  3831.             value = value you are looking for
  3832. Result:            result = 0 if successful; nonzero if unsuccessful
  3833. ------------------------- 
  3834. MENUNUM (macro)
  3835. Description:        extracts the menu number from a value
  3836. C Include File:     include/intuition/intuition.h
  3837. ML Include File:     none
  3838. Modula-2 Module:    Intuition
  3839. Syntax:            menuNumber = MENUNUM(menuValue)
  3840. C:            long MENUNUM(long)
  3841. Machine Language:    not available
  3842. Modula-2:        MENUNUM(menuValue: CARDINAL): CARDINAL
  3843. Arguments:        menuValue = 16-bit packed number representing the menu num-
  3844.             ber, item number, and subitem number
  3845. Result:            menuNumber = menu number (0-31); equals NOMENU if no
  3846.             menu was selected
  3847. -------------------------
  3848. ModifyIDCMP
  3849. Description:        modifies the state of a window's IDCMP
  3850. Library:        intuition.library
  3851. Offset:            -$0096 (-150)
  3852. Modula-2 Module:    Intuition
  3853. Syntax:            ModifyIDCMP(window, flags)
  3854. C:            void ModifyIDCMP(struct Window *, long)
  3855. Machine Language:    ModifyIDCMP(a0, d0)
  3856. Modula-2:        ModifyIDCMP(window: WindowPtr; flags: IDCMPFlagsSet)
  3857. Arguments:        window = window containing IDCMP
  3858.             flags = IDCMP flags
  3859. Result:            none
  3860. -------------------------
  3861. ModifyProp
  3862. Description:        modifies current state of proportional gadgets (see
  3863.             NewModifyProp)
  3864. Library:        intuition.library
  3865. Offset:            -$009C (-156)
  3866. Modula-2 Module:    Intuition
  3867. Syntax:            ModifyProp(propGadget, window, requester, flags, horizPot,
  3868.             vertPot, horizBody, vertBody)
  3869. C:            void ModifyProp(struct Gadget *, struct Window *, struct Request-
  3870.             er *, long, long, long, long, long)
  3871. Machine Language:    ModifyProp(a0, a1, a2, d0, d1, d2, d3, d4)
  3872. Modula-2:        ModifyProp(propGadget: GadgetPtr; window: WindowPtr; re-
  3873.             quester: RequesterPtr; flags: PropFlagSet; horizPot, vertPot,
  3874.             horizBody, vertBody: CARDINAL)
  3875. Arguments:        propGadget = proportional gadget to modify
  3876.             window = window containing proportional gadget
  3877.             requester = Requester structure; NULL if gadget is not part of a
  3878.             requester
  3879.             flags = new flags value
  3880.             horizPot = new horizontal pot value (position)
  3881.             vertPot = new vertical pot value (position)
  3882.             horizBody = new horizontal body value (size of slider)
  3883.             vertBody = new vertical body value (size of slider)
  3884. Result:            none
  3885. -------------------------
  3886. Move
  3887. Description:        moves the drawing pen to the specified position without drawing
  3888.             anything
  3889. Library:        layers.library
  3890. Offset:            -$00F0 (-240)
  3891. Modula-2 Module:    Drawing
  3892. Syntax:            Move(rastPort, x, y)
  3893. C:            void Move(struct RastPort *, long, long)
  3894. Machine Language:    Move(a0, d0, d1)
  3895. Modula-2:        Move(rastPort: RastPortPtr; x, y: INTEGER)
  3896. Arguments:        rastPort = RastPort structure
  3897.             x = new horizontal coordinate
  3898.             y = new vertical coordinate
  3899. Result:            none
  3900. -------------------------
  3901. MoveLayer
  3902. Description:        moves a nonbackdrop layer to a new position in the bitmap
  3903. Library:        layers.library
  3904. Offset:            -$003C (-60)
  3905. Modula-2 Module:    Layers
  3906. Syntax:            success = MoveLayer(dummy, layer, dx, dy)
  3907. C:            long MoveLayer(struct Layerlnfo *, struct Layer *, long, long)
  3908. Machine Language:    d0 = MoveLayer(a0, a1, d0, d1)
  3909. Modula-2:        MoveLayer(layer: LayerPtr; dx, dy: LONGINT): BOOLEAN
  3910. Arguments:        dummy = unused
  3911.             layer = nonbackdrop Layer structure
  3912.             dx = offset by which to move layer horizontally
  3913.             dy = offset by which to move layer vertically
  3914. Result:            success = TRUE is successful; FALSE if unsuccessful
  3915. -------------------------
  3916. MoveLayerInFrontOf
  3917. Description:        moves a layer in front of another layer
  3918. Library:        layers.library
  3919. Offset:            -$00A8 (-168)
  3920. Modula-2 Module:    Layers
  3921. Syntax:            success = MoveLayerInFrontOf(layer, target)
  3922. C:            long MoveLayerInFrontOf(struct Layer *, struct Layer *)
  3923. Machine Language:    d0 = MoveLayerInFrontOf(d0, a1)
  3924. Modula-2:        MoveLayerInFrontOf(layer, target: LayerPtr): BOOLEAN
  3925. Arguments:        layer = layer to move
  3926.             target = layer to have another layer placed on top of
  3927. Result:            success = TRUE if successful; FALSE if unsuccessful
  3928. -------------------------
  3929. MoveScreen
  3930. Description:        moves a screen vertically
  3931. Library:        intuition.library
  3932. Offset:            -$00A2 (-162)
  3933. Modula-2 Module:    Intuition
  3934. Syntax:            MoveScreen(screen, dx, dy)
  3935. C:            void MoveScreen(struct Screen *, long, long)
  3936. Machine Language:    MoveScreen(a0, d0, a1)
  3937. Modula-2:        MoveScreen(screen: ScreenPtr; dx, dy: INTEGER)
  3938. Arguments:        screen = screen to move
  3939.             dx = offset by which to move screen horizontally
  3940.             dy = offset by which to move screen vertically (not implemented
  3941.             as of system version 1.3)
  3942. Result:            none
  3943. -------------------------
  3944. MoveSprite
  3945. Description:        moves a sprite to specified location
  3946. Library:        graphics.library
  3947. Offset:            -$01AA (-426)
  3948. Modula-2 Module:    Sprites
  3949. Syntax:            MoveSprite(viewPort, sprite, x, y)
  3950. C:            long MoveSprite(struct ViewPort *, struct SimpleSprite *, long,
  3951.             long)
  3952. Machine Language:    MoveSprite(a0, a1, d0, d1)
  3953. Modula-2:        MoveSprite(viewPort: ViewPortPtr; sprite: SimpleSpritePtr; x, y:
  3954.             INTEGER)
  3955. Arguments:        viewPort = ViewPort structure
  3956.             sprite = SimpleSprite structure
  3957.             x = new horizontal position of sprite
  3958.             y = new vertical position of sprite
  3959. Result:            none
  3960. -------------------------
  3961. MoveWindow
  3962. Description:        moves a window
  3963. Library:        intuition.library
  3964. Offset:            -$00A8 (-168)
  3965. Modula-2 Module:    Intuition
  3966. Syntax:            MoveWindow(window, dx, dy)
  3967. C:            void MoveWindow(struct Window *, long, long)
  3968. Machine Language:    MoveWindow(a0, d0, a1)
  3969. Modula-2:        MoveWindow(window: WindowPtr; dx, dy: INTEGER)
  3970. Arguments:        window = window to move
  3971.             dx = offset by which to move window horizontally
  3972.             dy = offset by which to move window vertically
  3973. Result:            none
  3974. -------------------------
  3975. MrgCop
  3976. Description:        merges coprocessor instructions to form one instruction list
  3977. Library:        graphics.library
  3978. Offset:            -$00D2 (-210)
  3979. Modula-2 Module:    Views
  3980. Syntax:            MrgCop(view)
  3981. C:            void MrgCop(struct View *)
  3982. Machine Language:    MrgCop(a1)
  3983. Modula-2:        MrgCop(view: ViewPtr)
  3984. Arguments:        view = View structure
  3985. Result:            none
  3986. -------------------------
  3987. NewFontContents
  3988. Description:        creates an array of FontContents entries describing all fonts asso-
  3989.             ciated with specified font name
  3990. Library:        diskfont.library
  3991. Offset:            -$002A (-42)
  3992. Modula-2 Module:    none
  3993. Syntax:            fontContentsHeader = NewFontContents(fontsLock, fontName)
  3994. C:            struct FontContentsHeader *NewFontContents(BPTR, char *)
  3995. Machine Language:    d0 = NewFontContents(a0, a1)
  3996. Modula-2:        not available
  3997. Arguments:        fontsLock = BCPL pointer to a lock on the directory containing
  3998.             the fonts contents file (usually FONTS: directory)
  3999.             fontName = filename of font contents file (for example,
  4000.             "Diamond.font")
  4001. Result:            fontContentsHeader = pointer to a FontContentsHeader
  4002. -------------------------
  4003. NewLayerInfo
  4004. Description:        creates a Layer_Info structure
  4005. Library:        layers.library
  4006. Offset:            -$0090 (-144)
  4007. Modula-2 Module:    Layers
  4008. Syntax:            layerInfo = NewLayerInfo( )
  4009. C:            struct Layer_Info *NewLayerInfo(void)
  4010. Machine Language:    d0 = NewLayerInfo( )
  4011. Modula-2:        NewLayerInfo( ): LayerInfoPtr
  4012. Arguments:        none
  4013. Result:            layerInfo = pointer to initialized Layer_Info structure; NULL if
  4014.             unsuccessful
  4015. -------------------------
  4016. NewList
  4017. Description:        initializes a list header
  4018. Library:        amiga.lib (linked library)
  4019. ML Include File:    none
  4020. Modula-2 Module:    Lists
  4021. Syntax:            NewList(list)
  4022. C:            void NewList(struct List *)
  4023. Machine Language:    not available
  4024. Modula-2:        NewList(VAR list: List)
  4025. Arguments:        list = List structure
  4026. Result:            none
  4027. -------------------------
  4028. NewModifyProp
  4029. Description:        modifies current state of proportional gadgets, with selective gad-
  4030.             get refresh
  4031. Library:        intuition.library
  4032. Offset:            -$01D4 (-468)
  4033. Modula-2 Module:    Intuition
  4034. Syntax:            NewModifyProp(propGadget, window, requester, flags, horizPot, 
  4035.             vertPot, horizBody, vertBody, gadgetNumber)
  4036. C:                void NewModifyProp(struct Gadget *, struct Window *, struct Re-
  4037.             quester *, long, long, long, long, long, long)
  4038. Machine Language:    NewModifyProp(a0, a1, a2, d0, d1, d2, d3, d4, d5)
  4039. Modula-2:        NewModifyProp(propGadget: GadgetPtr; window: WindowPtr; re-
  4040.             quester: RequesterPtr; flags: PropFlagSet; horizPot, vertPot,
  4041.             horizBody, vertBody: CARDINAL; gadgetNumber: INTEGER)
  4042. Arguments:        propGadget = proportional gadget to modify
  4043.             window = window containing proportional gadget
  4044.             requester = Requester structure; NULL if gadget is not part of a
  4045.             requester
  4046.             flags = new flags value
  4047.             horizPot = new horizontal pot value (position)
  4048.             vertPot = new vertical pot value (position)
  4049.             horizBody = new horizontal body value (size of slider)
  4050.             vertBody = new vertical body value (size of slider)
  4051.             gadgetNumber = number of gadgets to refresh after gadget modi-
  4052.             fication; -1 to refresh all gadgets to the end of gadget list
  4053. Result:            none
  4054. -------------------------
  4055. NewRegion
  4056. Description:        creates an empty Region structure
  4057. Library:        graphics.library
  4058. Offset:            -$0204 (-516)
  4059. Modula-2 Module:    Regions
  4060. Syntax:            region = NewRegion( )
  4061. C:                struct Region *NewRegion(void)
  4062. Modula-2:        NewRegion(VAR list: List)
  4063.             NewRegion( ): RegionPrt
  4064. Arguments:        none
  4065. Result:            region = pointer to initialized Region structure; NULL if not
  4066.             enough memory
  4067. -------------------------
  4068. ObtainConfigBinding 
  4069. Description:        attempts to get permission to bind drivers 
  4070. Library:        expansion.library 
  4071. Offset:            -$0078 (-120) 
  4072. Modula-2 Module:    none
  4073. Syntax:            ObtainConfigBinding( )
  4074. C:            void ObtainConfigBinding(void)
  4075. Machine Language:    ObtainConfigBinding( )
  4076. Modula-2:        not available
  4077. Arguments:        none
  4078. Result:            none
  4079. ------------------------
  4080. ObtainSemaphore
  4081. Description:        obtains exclusive use of a signal semaphore
  4082. Library:        exec.library
  4083. Offset:            -$0234 (-564)
  4084. Modula-2 Module:    Semaphores
  4085. Syntax:            ObtainSemaphore(signalSemaphore)
  4086. C:            void ObtainSemaphore(struct SignalSemaphore *)
  4087. Machine Language:    ObtainSemaphore(a0)
  4088. Modula-2:              ObtainSemaphore(signalSemaphore: SignalSemaphorePtr)
  4089. Arguments:        signalSemaphore = initialized SignalSemaphore structure
  4090. Result:            none
  4091. -------------------------
  4092. ObtainSemaphoreList
  4093. Description:        obtains exclusive use of a list of signal semaphores
  4094. Library:        exec.library
  4095. Offset:            -$0246 (-582)
  4096. Modula-2 Module:    Semaphores
  4097. Syntax:            ObtainSemaphoreList(list)
  4098. C:            void ObtainSemaphoreList(struct List *)
  4099. Machine Language:    ObtainSemaphoreList(a0)
  4100. Modula-2:        ObtainSemaphoreList(list: SignalSemaphorePtr)
  4101. Arguments:        list = List structure representing a list of signal semaphores
  4102. Result:            none
  4103. -------------------------
  4104. OFFDISPLAY (macro)
  4105. Description:        clears the display DMA bit in the DMA control register
  4106. C Include File:     include/graphics/gfxmacros.h
  4107. ML Include File:     none
  4108. Modula-2 Module:    CustomHardware
  4109. Syntax:            OFF_DISPLAY( )
  4110. C:            void OFF_DISPLAY(void)
  4111. Machine Language:    not available
  4112. Modula-2:        OFFDISPLAY( )
  4113. Arguments:        none
  4114. Result:            none
  4115. -------------------------
  4116. OffGadget
  4117. Description:        disables a gadget
  4118. Library:        intuition.library
  4119. Offset:            -$00AE (-174)
  4120. Modula-2 Module:    Intuition
  4121. Syntax:            OffGadget(gadget, window, requester)
  4122. C:            void OffGadget(struct Gadget , struct Window *, struct Requester *)
  4123. Machine Language:    OffGadget(a0, a1, a2)
  4124. Modula-2:        OffGadget(gadget: GadgetPtr; window: WindowPtr; requester:
  4125.             RequesterPtr)
  4126. Arguments:        gadget = gadget to disable
  4127.             window = window containing gadget
  4128.             requester = Requester structure; NULL if gadget is not part of a
  4129.             requester
  4130. Result:            none
  4131. -------------------------
  4132. OffMenu
  4133. Description:        disables a menu or menu item
  4134. Library:        intuition.library
  4135. Offset:            -$00B4 (-180)
  4136. Modula-2 Module:    Intuition
  4137. Syntax:            OffMenu(window, menuNumber)
  4138. C:            void OffMenu(struct Window *, long)
  4139. Machine Language:    OffMenu(a0, d0)
  4140. Modula-2:        OffMenu(window: WindowPtr; menuNumber: CARDINAL)
  4141. Arguments:        window = window containing menu or menu item
  4142.             menuNumber = number specifying menu or menu item to dis-
  4143.             able-bits 0-4 specify menu number, bits 5-10 specify menu
  4144.             item, and bits 11-15 specify menu subitems
  4145. Result:            none
  4146. -------------------------
  4147. OFF_SPRITE (macro)
  4148. Description:        clears the sprite DMA bit in the DMA control register
  4149. C Include File:     include/graphics/gfxmacros.h
  4150. ML Include File:     none
  4151. Modula-2 Module:    CustomHardware
  4152. Syntax:            OFF_SPRITE( )
  4153. C:            void OFF_SPRITE(void)
  4154. Machine Language:    not available
  4155. Modula-2:        OFFSPRITE( )
  4156. Arguments:        none
  4157. Result:            none
  4158. -------------------------
  4159. OFF_VBLANK (macro) 
  4160. Description:        clears the vertical blanking interrupt (bit 5) in the interrupt control 
  4161.             register 
  4162. C Include File:     include/graphics/gfxmacros.h 
  4163. ML Include File:     none 
  4164. Modula-2 Module:    none 
  4165. Syntax:            OFF_VBLANK( ) 
  4166. C:            void OFF_VBLANK(void) 
  4167. Machine Language:    not available
  4168. Modula-2:        not available
  4169. Arguments:        none
  4170. Result:            none
  4171. -------------------------
  4172. OldOpenLibrary
  4173. Description:        obsolete version of the OpenLibrary( ) function which gains access
  4174.             to a library without requiring a version number; do not use this
  4175.             function-use OpenLibrary( ) instead
  4176. Library:        exec.library
  4177. Offset:            -$0198 (-408)
  4178. Modula-2 Module:    none
  4179. Syntax:            library = Old0penLibrary(name)
  4180. C:            struct Library *Old0penLibrary(char *)
  4181. Machine Language:    d0 = Old0penLibrary(a1)
  4182. Modula-2:        not available
  4183. Arguments:        name = name of desired library
  4184. Result:            library = base pointer to desired library; NULL if library cannot
  4185.             be found
  4186. -------------------------
  4187. ON_DISPLAY (macro)
  4188. Description:        sets the display DMA bit in the DMA control register
  4189. C Include File:     include/graphics/gfxmacros.h
  4190. ML Include File:     none
  4191. Modula-2 Module:    CustomHardware
  4192. Syntax:            ON_DISPLAY( )
  4193. C:            void ON_DISPLAY(void)
  4194. Machine Language:    not available
  4195. Modula-2:        ONDISPLAY( )
  4196. Arguments:        none
  4197. Result:            none
  4198. -------------------------
  4199. OnGadget
  4200. Description:        enables a gadget
  4201. Library:        intuition.library
  4202. Offset:            -$00BA (-186)
  4203. Modula-2 Module:    Intuition
  4204. Syntax:            OnGadget(gadget, window, requester)
  4205. C:            void OnGadget(struct Gadget *, struct Window *, struct Requester *)
  4206. Machine Language:    OnGadget(a0, a1, a2)
  4207. Modula-2:        OnGadget(gadget: GadgetPtr; window: WindowPtr; requester:
  4208.             RequesterPtr)
  4209. Arguments:        gadget = gadget to enable
  4210.             window = window containing gadget
  4211. requester = Requester structure; NULL if gadget is not part of a
  4212.             requester
  4213. Result:            none
  4214. -------------------------
  4215. OnMenu
  4216. Description:        enables a menu or menu item
  4217. Library:        intuition.library
  4218. Offset:            -$00C0 (-192)
  4219. Modula-2 Module:    Intuition
  4220. Syntax:            OnMenu(window, menuNumber)
  4221. C:            void OnMenu(struct Window *, long)
  4222. Machine Language:    OnMenu(a0, d0)
  4223. Modula-2:        OnMenu(window: WindowPtr; menuNumber: CARDINAL)
  4224. Arguments:        window = window containing menu or menu item
  4225.             menuNumber = number specifying menu or menu item to en-
  4226.             able-bits 0-4 specify menu number, bits 5-10 specify menu
  4227.             item, and bits 11-15 specify menu subitems
  4228. Result:            none    
  4229. -------------------------  
  4230. ON_SPRITE (macro)
  4231. Description:        sets the sprite DMA bit in the DMA control register
  4232. C Include File:     include/graphics/gfxmacros.h
  4233. ML Include File:     none
  4234. Modula-2 Module:    CustomHardware
  4235. Syntax:            ON_SPRITE( )
  4236. C:            void ON_SPRITE(void)
  4237. Machine Language:    ON_SPRITE( )
  4238. Modula-2:        ONSPRITE( )
  4239. Arguments:        none
  4240. Result:            none
  4241. -------------------------
  4242. ON_VBLANK (macro) 
  4243. Description:        sets the vertical blanking interrupt (bit 5) in the interrupt control 
  4244.             register 
  4245. C Include File:     include/graphics/gfxmacros.h 
  4246. ML Include File:     none 
  4247. Modula-2 Module:    none 
  4248. Syntax:            ON_VBLANK( ) 
  4249. C:            void ON_VBLANK(void) 
  4250. Machine Language:    ON_VBLANK( )
  4251. Modula-2:        not available
  4252. Arguments:        none
  4253. Result:            none
  4254. -------------------------
  4255. Open
  4256. Description:        opens a file for input or output
  4257. Library:        dos.library
  4258. Offset:            -$001E (-30)
  4259. Modula-2 Module:    DOS
  4260. Syntax:            file = Open(name, accessMode)
  4261. C:            BPTR Open(char *, long)
  4262. Machine Language:    d0 = Open(d1, d2)
  4263. Modula-2:        Open(name: STRPTR; accessMode: LONGINT): FileHandle
  4264. Arguments:        name = NULL terminated string specifying filename
  4265.             accessMode = type of file access desired-MODE_OLDFILE for
  4266.             reading, MODE_NEWFILE for writing
  4267. Result:            file = BCPL pointer to file handle; NULL if unsuccessful
  4268. -------------------------
  4269. OpenDevice
  4270. Description:        provides access to a device and initializes an IO request block for
  4271.             access to the device
  4272. Library:        exec.library
  4273. Offset:            -$01BC (-444)
  4274. Modula-2 Module:    Devices
  4275. Syntax:            error = OpenDevice(name, unitNumber, ioRequest, flags)
  4276. C:            long OpenDevice(char *, long, struct IORequest *, long)
  4277. Machine Language:    d0 = OpenDevice(a0, d0, a1, d2)
  4278. Modula-2:        OpenDevice(name: STRPTR; unitNumber: LONGCARD;
  4279.             ioRequest: ADDRESS; flags: LONGBITSET): INTEGER
  4280. Arguments:        name = NULL terminated string specifying device name
  4281.             unitNumber = desired unit number for device (device specific)
  4282.             ioRequest = IORequest block to initialize
  4283.             flags = additional device information (device specific)
  4284. Result:            error = 0 if successful; nonzero if unsuccessful
  4285. -------------------------
  4286. OpenDiskFont
  4287. Description:        gains access to a disk-resident font
  4288. Library:        diskfont.library
  4289. Offset:            -$001E (-30)
  4290. Modula-2 Module:    DiskFont
  4291. Syntax:            font = OpenDiskFont(textAttr)
  4292. C:            struct TextFont *OpenDiskFont(struct TextAttr *)
  4293. Machine Language:    d0 = OpenDiskFont(a0)
  4294. Modula-2:        OpenDiskFont(textAttr: TextAttrPtr): TextFontPtr
  4295. Arguments:        textAttr = TextAttr structure that describes the desired font
  4296. Result:            font = pointer to desired TextFont structure; 0 if unsuccessful
  4297. -------------------------
  4298. OpenFont
  4299. Description:        gains access to a memory-resident font
  4300. Library:        graphics.library
  4301. Offset:            -$0048 (-72)
  4302. Modula-2 Module:    Text
  4303. Syntax:            font = OpenFont(textAttr)
  4304. C:            struct TextFont *OpenFont(struct TextAttr *)
  4305. Machine Language:    d0 = OpenFont(a0)
  4306. Modula-2:        OpenFont(textAttr: TextAttrPtr): TextFontPtr
  4307. Arguments:        textAttr = TextAttr structure that describes the desired font
  4308. Result:            font = pointer to desired TextFont structure; 0 if unsuccessful
  4309. ------------------------- 
  4310. OpenLibrary
  4311. Description:        gains access to a library
  4312. Library:        exec.library
  4313. Offset:            -$0228 (-552)
  4314. Modula-2 Module:    Libraries
  4315. Syntax:            library = OpenLibrary(name, version)
  4316. C:            struct Library *OpenLibrary(char *, long)
  4317. Machine Language:    d0 = OpenLibrary(a1, d0)
  4318. Modula-2:        OpenLibrary(name: STRPTR; version: LONGCARD): LibraryPtr
  4319. Arguments:        name = name of desired library
  4320.             version = lowest acceptable library version number; 0 if you
  4321.             don't care
  4322. Result:            library = base pointer to desired library; NULL if library cannot
  4323.             be found
  4324. -------------------------
  4325. OpenResource
  4326. Description:        gains access to a resource
  4327. Library:        exec.library
  4328. Offset:            -$01F2 (-498)
  4329. Modula-2 Module:    Resources
  4330. Syntax:            resource = OpenResource(name)
  4331. C:            struct Resource *OpenResource(char *)
  4332. Machine Language:    d0 = OpenResource(a1)
  4333. Modula-2:        OpenResource(name: STRPTR): ResourcePtr
  4334. Arguments:        name = name of desired resource
  4335. Result:            resource = pointer to resource; NULL if unsuccessful
  4336. -------------------------
  4337. OpenScreen
  4338. Description:        opens an Intuition screen
  4339. Library:        intuition.library
  4340. Offset:            -$00C6 (-198)
  4341. Modula-2 Module:    Intuition
  4342. Syntax:            screen = OpenScreen(newScreen)
  4343. C:            struct Screen *OpenScreen(struct NewScreen *)
  4344. Machine Language:    d0 = OpenScreen(a0)
  4345. Modula-2:        OpenScreen(newScreen: NewScreenPtr): ScreenPtr
  4346. Arguments:        newScreen = NewScreen structure that describes screen to open
  4347. Result:            screen = pointer to Screen structure; NULL if unsuccessful
  4348. ------------------------- 
  4349. OpenWindow
  4350. Description:        opens an Intuition window
  4351. Library:        intuition.library
  4352. Offset:            -$00CC (-204)
  4353. Modula-2 Module:    Intuition
  4354. Syntax:            window = OpenWindow(newWindow)
  4355. C:            struct Window *OpenWindow(struct NewWindow *)
  4356. Machine Language:    d0 = OpenWindow(a0)
  4357. Modula-2:        OpenWindow(newWindow: NewWindowPtr): WindowPtr
  4358. Arguments:        newWindow = NewWindow structure that describes window to
  4359.             open
  4360. Result:            window = pointer to Window structure; NULL if unsuccessful
  4361. -------------------------
  4362. OpenWorkBench
  4363. Description:        opens the Workbench screen
  4364. Library:        intuition.library
  4365. Offset:            -$00D2 (-210)
  4366. Modula-2 Module:    Intuition
  4367. Syntax:            success = OpenWorkBench( )
  4368. C:            long OpenWorkBench(void)
  4369. Machine Language:    d0 = OpenWorkBench( )
  4370. Modula-2:        OpenWorkBench( ): BOOLEAN
  4371. Arguments:        none
  4372. Result:            success = TRUE if successful (value represents pointer to Work-
  4373.             Bench screen-this may change in system versions greater than
  4374.             1.3); FALSE (NULL) if unsuccessful
  4375. -------------------------
  4376. OrRectRegion
  4377. Description:        performs a two-dimensional OR operation of a rectangle with a
  4378.             region, leaving the result in the region
  4379. Library:        graphics.library
  4380. Offset:            -$01FE (-510)
  4381. Modula-2 Module:    Regions
  4382. Syntax:            success = OrRectRegion(region, rectangle)
  4383. C:            long OrRectRegion(struct Region *, struct Rectangle *)
  4384. Machine Language:    d0 = OrRectRegion(a0, a1)
  4385. Modula-2:        OrRectRegion(region: RegionPtr; rectangle: RectanglePtr):
  4386.             BOOLEAN
  4387. Arguments:        region = Region structure
  4388.             rectangle = Rectangle structure
  4389. Result:            success = TRUE if successful; FALSE if unsuccessful
  4390. ------------------------- 
  4391. OrRegionRegion
  4392. Description:        performs a two-dimensional OR operation of one region with a
  4393.             second region, leaving the result in second region
  4394. Library:        graphics.library
  4395. Offset:            -$0264 (-612)
  4396. Modula-2 Module:    Regions
  4397. Syntax:            success = OrRegionRegion(region1, region2)
  4398. C:            long OrRegionRegion(struct Region *, struct Region *)
  4399. Machine Language:    d0 = OrRegionRegion(a0, a1)
  4400. Modula-2:        OrRegionRegion(region1, region2: RegionPtr): BOOLEAN
  4401. Arguments:        region1 = Region structure
  4402.             region2 = Region structure
  4403. Result:            success = TRUE if successful; FALSE if unsuccessful
  4404. -------------------------
  4405. Output
  4406. Description:        gets the initial output file handle assigned to a program
  4407. Library:        dos.library
  4408. Offset:            -$003C (-60)
  4409. Modula-2 Module:    DOS
  4410. Syntax:            file = Output( )
  4411. C:            BPTR Output(void)
  4412. Machine Language:    d0 = Output( )
  4413. Modula-2:        Output( ): FileHandle
  4414. Arguments:        none
  4415. Result:            file = BCPL pointer to a file handle
  4416. -------------------------
  4417. OwnBlitter
  4418. Description:        reserves the blitter for private use
  4419. Library:        graphics.library
  4420. Offset:            -$01C8 (-456)
  4421. Modula-2 Module:    Blitter
  4422. Syntax:            OwnBlitter( )
  4423. C:            void OwnBlitter(void)
  4424. Machine Language:    OwnBlitter( )
  4425. Modula-2:        OwnBlitter( )
  4426. Arguments:        none
  4427. Result:            none
  4428. ------------------------- 
  4429. ParentDir
  4430. Description:        obtains the parent directory of a file or directory
  4431. Library:        dos.library
  4432. Offset:            -$00D2 (-210)
  4433. Modula-2 Module:    DOS
  4434. Syntax:            lock = ParentDir(lock)
  4435. C:            BPTR ParentDir(BPTR)
  4436. Machine Language:    d0 = ParentDir(d1)
  4437. Modula-2:        ParentDir(lock: FileLock): FileLock
  4438. Arguments:        lock = BCPL pointer to lock associated with child file or directory
  4439. Result:            lock = BCPL pointer to lock associated with parent directory
  4440. -------------------------
  4441. PeekCLMark
  4442. Description:        gets byte located in mark position of a character list
  4443. Library:        clist.library
  4444. Offset:            -$0084 (-132)
  4445. Modula-2 Module:    none
  4446. Syntax:            byte = PeekCLMark(cList)
  4447. C:            long PeekCLMark(long)
  4448. Machine Language:    d0 = PeekCLMark(a0)
  4449. Modula-2:        not available
  4450. Arguments:        cList = character list descriptor
  4451. Result:            byte = byte located in mark position of character list
  4452. -------------------------
  4453. Permit
  4454. Description:        permits task rescheduling halted by Forbid( )
  4455. Library:        exec.library
  4456. Offset:            -$008A (-138)
  4457. Modula-2 Module:    Interrupts
  4458. Syntax:            Permit( )
  4459. C:            void Permit(void)
  4460. Machine Language:    Permit( )
  4461. Modula-2:        Permit( )
  4462. Arguments:        none
  4463. Result:            none
  4464. -------------------------
  4465. PolyDraw
  4466. Description:        draws a series of connected lines from current pen position to
  4467.             points specified by a table of (x,y) coordinates
  4468. Library:        graphics.library
  4469. Offset:            -$0150 (-336)
  4470. Modula-2 Module:    Pens
  4471. Syntax:            PolyDraw(rastPort, count, array)
  4472. C:            long PolyDraw(struct RastPort *, long, short *)
  4473. Machine Language:    PolyDraw(al, d0, a0)
  4474. Modula-2:        PolyDraw(rastPort: RastPortPtr; count: INTEGER; array:
  4475.             ADDRESS)
  4476. Arguments:        rastPort = RastPort to draw lines in
  4477.             count = number of coordinates in array
  4478.             array = pointer to array of coordinates
  4479. Result:            none
  4480. -------------------------
  4481. printf
  4482. Description:        prints a formatted string to the standard output (Lattice and Manx
  4483.             users: if you link with lc.lib or c.lib, this is not the function you're
  4484.             calling)
  4485. Library:        amiga.lib (linked library)
  4486. Modula-2 Module:    none
  4487. Syntax:            printf(string, values...)
  4488. C:            void printf(char *, long...)
  4489. Machine Language:    move.l #value,-(sp) ;may have several values 
  4490.             pea string 
  4491.             jsr _printf 
  4492.             add.l #8,sp ;(2 arguments * 4 bytes = 8)
  4493. Modula-2:        not available
  4494. Arguments:        string = string containing optional C formatting commands (%); if
  4495.             you're passing longword values on the stack (as shown above) be
  4496.             sure to follow the percent symbol with a lowercase L
  4497.             values = values or addresses of strings to print; this routine
  4498.             knows how many values are on the stack by checking the number
  4499.             of formatting commands in the string argument
  4500. Result:            none
  4501. -------------------------
  4502. PrintIText
  4503. Description:        prints text according to its IntuiText specifications
  4504. Library:        intuition.library
  4505. Offset:            -$00D8 (-216)
  4506. Modula-2 Module:    Intuition
  4507. Syntax:            PrintIText(rastPort, intuiText, leftEdge, topEdge)
  4508. C:                void PrintIText(struct RastPort *, struct IntuiText *, long, long)
  4509. Machine Language:    PrintIText(a0, a1, d0, d1)
  4510. Modula-2:        PrintIText(rastPort: RastPortPtr; intuiText: IntuiTextPtr; leftEdge,
  4511.             topEdge: INTEGER)
  4512. Arguments:        rastPort = RastPort structure to receive text
  4513.             intuiText = IntuiText structure containing text
  4514.             leftEdge = horizontal position of text within RastPort
  4515.             topEdge = vertical position of text within RastPort
  4516. Result:            none
  4517. -------------------------
  4518. Procure
  4519. Description:        obtains a message-based semaphore
  4520. Library:        exec.library
  4521. Offset:            -$021C (-540)
  4522. Modula-2 Module:    Semaphores
  4523. Syntax:            success = Procure(semaphore, message)
  4524. C:                long Procure(struct Semaphore *, struct Message *)
  4525. Machine Language:    d0 = Procure(a0, a1)
  4526. Modula-2:        Procure(semaphore: SemaphorePtr; message: MessagePtr):
  4527.              BOOLEAN
  4528. Arguments:        semaphore = Semaphore structure
  4529.             message = Message structure to be used if desired semaphore is
  4530.             unavailable
  4531. Result:            success = TRUE if successful; FALSE if unsuccessful
  4532. -------------------------
  4533. PutCLBuf
  4534. Description:        converts contiguous data into a character list
  4535. Library:        clist.library
  4536. Offset:            -$006C (-108)
  4537. Modula-2 Module:    none
  4538. Syntax:            error = PutCLBuf(cList, buffer, length)
  4539. C:                long PutCLBuf(long, char *, long)
  4540. Machine Language:    d0 = PutCLBuf(a0, a1, d1)
  4541. Modula-2:        not available
  4542. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  4543.             StrToCL( )
  4544.             buffer = buffer containing data to be converted
  4545.             length = size of buffer in bytes
  4546. Result:            error = 0 if successful; nonzero if unsuccessful
  4547. -------------------------
  4548. PutCLChar
  4549. Description:        adds a byte to the end of a character list
  4550. Library:        clist.library
  4551. Offset:            -$003C (-60)
  4552. Modula-2 Module:    none
  4553. Syntax:            error = PutCLChar(cList, byte)
  4554. C:            long PutCLChar(long, long)
  4555. Machine Language:    d0 = PutCLChar(a0, d0)
  4556. Modula-2:        not available
  4557. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  4558.             StrToCL( )
  4559.             byte = byte to be added to end of character list
  4560. Result:            error = 0 if successful; nonzero if unsuccessful
  4561. -------------------------
  4562. PutCLWord
  4563. Description:        adds a word to the end of a character list
  4564. Library:        clist.library
  4565. Offset:            -$0054 (-84)
  4566. Modula-2 Module:    none
  4567. Syntax:            error = PutCLWord(cList, word)
  4568. C:            long PutCLWord(long)
  4569. Machine Language:    d0 = PutCLWord(a0, d0)
  4570. Modula-2:        not available
  4571. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  4572.             StrToCL( )
  4573.             word = word to be added to end of character list
  4574. Result:            error = 0 if successful; nonzero if unsuccessful
  4575. -------------------------
  4576. PutDiskObject
  4577. Description:        writes a Workbench DiskObject to disk as an .info file
  4578. Library:        icon.library
  4579. Offset:            -$0054 (-84)
  4580. Modula-2 Module:    Icon
  4581. Syntax:            success = PutDiskObject(name, diskObj)
  4582. C:            long PutDiskObject(char *, struct DiskObject *)
  4583. Machine Language:    d0 = PutDiskObject(a0, a1)
  4584. Modula-2:        PutDiskObject(name: STRPTR; diskObj: DiskObjectPtr): BOOLEAN
  4585. Arguments:        name = name of object
  4586.             diskObj = DiskObject structure (.info file)
  4587. Result:            success = nonzero if successful
  4588. -------------------------
  4589. PutIcon
  4590. Description:        writes a DiskObject to disk as an .info file
  4591. Library:        icon.library
  4592. Offset:            -$0030 (-48)
  4593. Modula-2 Module:    none
  4594. Syntax:            success = PutIcon(name, icon)
  4595. C:           long PutIcon(char *, struct DiskObject *)
  4596. Machine Language:    d0 = PutIcon(a0, a1)
  4597. Modula-2:        not available
  4598. Arguments:        name = name of icon (.info file)
  4599.             icon = DiskObject structure
  4600. Result:            success = nonzero if successful
  4601. -------------------------
  4602. PutMsg
  4603. Description:        gets next message from a message port
  4604. Library:        exec.library
  4605. Offset:            -$016E (-366)
  4606. Modula-2 Module:    Ports
  4607. Syntax:            PutMsg(port, message)
  4608. C:                void PutMsg(struct MsgPort *, struct Message *)
  4609. Machine Language:    PutMsg(a0, a1)
  4610. Modula-2:        PutMsg(port: MsgPortPtr; message: ADDRESS)
  4611. Arguments:        port = message port to receive message
  4612.             message = Message structure containing message to send
  4613. Result:            none
  4614. -------------------------
  4615. PutWBObject
  4616. Description:        writes a WBObject to disk as an .info file
  4617. Library:        icon.library
  4618. Offset:            -$0024 (-36)
  4619. Modula-2 Module:    none
  4620. Syntax:            success = PutWBObject(name, object)
  4621. C:            long PutWBObject(char *, struct WBObject *)
  4622. Machine Language:    d0 = PutWBObject(a0, a1)
  4623. Modula-2:        not available
  4624. Arguments:        name = name of WBObject (.info file)
  4625.             object = WBObject structure
  4626. Result:            success = nonzero if successful
  4627. ------------------------- 
  4628. QBlit
  4629. Description:        queues up a blitter request
  4630. Library:        graphics.library
  4631. Offset:            -$0114 (-276)
  4632. Modula-2 Module:    Blitter
  4633. Syntax:            QBlit(blitNode)
  4634. C:            void QBlit(struct BlitNode *)
  4635. Machine Language:    QBlit(a1)
  4636. Modula-2:        QBlit(blitNode: bltnodePtr)
  4637. Arguments:        blitNode = BlitNode structure containing link information and
  4638.             address of your blitter routine
  4639. Result:            none
  4640. -------------------------
  4641. QBSlit
  4642. Description:        queues and synchronizes a blitter request with the video beam
  4643. Library:        graphics.library
  4644. Offset:            -$0126 (-294)
  4645. Modula-2 Module:    Blitter
  4646. Syntax:            QBSlit(blitNode)
  4647. C:            void QBSlit(struct BlitNode *)
  4648. Machine Language:    QBSlit(a1)
  4649. Modula-2:        QBSlit(blitNode: bltnodePtr)
  4650. Arguments:        blitNode = BlitNode structure containing link information and
  4651.             address of your blitter routine
  4652. Result:            none
  4653. -------------------------
  4654. RangeRand
  4655. Description:        generates a random integer within a specified range
  4656. Library:        amiga.lib (linked library)
  4657. Modula-2 Module:    none
  4658. Syntax:            rnd = RangeRand(range)
  4659. C:            long RangeRand(long)
  4660. Machine Language:    move.l range,-(sp)
  4661.             jsr _RangRand ;rnd returned in d0
  4662.             addq.l #4,sp
  4663. Modula-2:        not available
  4664. Arguments:        range = highest integer acceptable
  4665. Result:            rnd = random number between 0 and value of range argument
  4666. -------------------------
  4667. RASSIZE (macro)
  4668. Description:        calculates the memory requirements for a raster bitmap of the
  4669.             specified with and height
  4670. C Include File:        include/graphics/gfx.h
  4671. ML Include File:    none
  4672. Modula-2 Module:    Graphics
  4673. Syntax:            bytes = RASSIZE(width, height)
  4674. C:            long RASSIZE(long, long)
  4675. Machine Language:    not available
  4676. Modula-2:        RASSIZE(width, height: LONGCARD)
  4677. Arguments:        width = width of hypothetical bitmap in pixels
  4678.             height = height of hypothetical bitmap in pixels
  4679. Result:            bytes = number of bytes required to contain raster bitmap
  4680. -------------------------
  4681. RawDoFmt
  4682. Description:        formats data into a character stream using C formatting
  4683.             commands (%)
  4684. Library:        exec.library
  4685. Offset:            -$020A (-522)
  4686. Modula-2 Module:    Exec
  4687. Syntax:            RawDoFmt(formatString, dataStream, putChProc, putChData)
  4688. C:            void RawDoFmt(char *, APTR, void (*)(), APTR)
  4689. Machine Language:    RawDoFmt(a0, a1, a2, a3)
  4690. Modula-2:        RawDoFmt(formatString, dataStream: ADDRESS; putChProc:
  4691.             PROC; putChData: ADDRESS)
  4692. Arguments:        formatString = string with optional C formatting commands (%)
  4693.             dataStream = stream of data that is interpreted according to the
  4694.             formatString
  4695.             putChProc = address of procedure to call with each character to
  4696.             be output, where procedure is called as PutChProc(char,
  4697.             putChData)
  4698.             putChData = value to pass to PutChProc
  4699. Result:            none
  4700. -------------------------
  4701. Read
  4702. Description:        reads data from a file
  4703. Library:        dos.library
  4704. Offset:            -$002A (-42)
  4705. Modula-2 Module:    DOS
  4706. Syntax:            actualLength = Read(file, buffer, length)
  4707. C:            long Read(BPTR, char *, long)
  4708. Machine Language:    d0 = Read(d1, d2, d3)
  4709. Modula-2:        Read(file: FileHandle; buffer: ADDRESS; length: LONGINT):
  4710.             LONGINT
  4711. Arguments:        file = BCPL pointer to a file handle
  4712.             buffer = address of memory block to receive data
  4713.             length = number of bytes to read (must not exceed buffer size)
  4714. Result:            actualLength = actual number of bytes received
  4715. -------------------------
  4716. ReadExpansionByte
  4717. Description:        reads a byte nybble-by-nybble from a new-style expansion board
  4718. Library:        expansion.library
  4719. Offset:            -$0060 (-96)
  4720. Modula-2 Module:    Expansion
  4721. Syntax:            byte = ReadExpansionByte(board, offset)
  4722. C:            long ReadExpansionByte(long, long)
  4723. Machine Language:    d0 = ReadExpansionByte(a0, d0)
  4724. Modula-2:        ReadExpansionByte(board: ADDRESS; offset: LONGCARD):
  4725.             INTEGER    
  4726. Arguments:        board = base address of expansion board
  4727.             offset = logical offset from board base
  4728. Result:            byte = data received; -1 if an error occurred
  4729. -------------------------
  4730. ReadExpansionRom
  4731. Description:        reads a new-style expansion board's configuration ROM space
  4732. Library:        expansion.library
  4733. Offset:            -$0066 (-102)
  4734. Modula-2 Module:    Expansion
  4735. Syntax:            error = ReadExpansionRom(board, configDev)
  4736. C:            long ReadExpansionRom(long, long)
  4737. Machine Language:    d0 = ReadExpansionRom(a0, a1)
  4738. Modula-2:        ReadExpansionRom(board: ADDRESS; configDev: ADDRESS):
  4739.             BOOLEAN
  4740. Arguments:        board = base address of expansion board
  4741.             configDev = ConfigDev structure to receive ROM data
  4742. Result:            error = 0 if successful; nonzero if an error occurred
  4743. -------------------------
  4744. ReadPixel
  4745. Description:        finds the color register (pen) used to color a specific pixel
  4746. Library:        graphics.library
  4747. Offset:            -$013E (-318)
  4748. Modula-2 Module:    Pens
  4749. Syntax:            pen = ReadPixel(rastPort, x, y)
  4750. C:            long ReadPixel(struct RastPort *, long, long)
  4751. Machine Language:    d0 = ReadPixel(a0, d0, d1)
  4752. Modula-2:        ReadPixel(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
  4753. Arguments:        rastPort = RastPort structure
  4754.             x = horizontal coordinate of pixel
  4755.             y = vertical coordinate of pixel
  4756. Result:            pen = pen number; -1 if pixel lies outside boundaries of rastport
  4757. -------------------------
  4758. RectFill
  4759. Description:        fills a rectangular area using the current pen color, outline color,
  4760.             secondary color, and pattern
  4761. Library:        graphics.library
  4762. Offset:            -$0132 (-306)
  4763. Modula-2 Module:    Pens
  4764. Syntax:            RectFill(rastPort, xmin, ymin, xmax, ymax)
  4765. C:            void RectFill(struct RastPort *, long, long, long, long)
  4766. Machine Language:    RectFill(a0, d0, d1, d2, d3)
  4767. Modula-2:        RectFill(rastPortPtr: RastPort; xmin, ymin, xmax, ymax: INTEGER)
  4768. Arguments:        rastPort = RastPort structure
  4769.             xmin = horizontal coordinate rectangle's upper left corner
  4770.             ymin = vertical coordinate rectangle's upper left corner
  4771.             xmax = horizontal coordinate rectangle's lower right corner
  4772.             ymax = vertical coordinate rectangle's lower right corner
  4773. Result:            none
  4774. -------------------------
  4775. RefreshGadgets
  4776. Description:        redraws a gadget and all following gadgets in gadget list
  4777. Library:        intuition.library
  4778. Offset:            -$00DE (-222)
  4779. Modula-2 Module:    Intuition
  4780. Syntax:            RefreshGadgets(gadgets, window, requester)
  4781. C:            void RefreshGadgets(struct Gadget *, struct Window *, struct Re-
  4782.             quester *)
  4783.  
  4784. Machine Language:    RefreshGadgets(a0, a1, a2)
  4785. Modula-2:        RefreshGadgets(gadgets: GadgetPtr; window: WindowPtr; request-
  4786.             er: RequesterPtr)
  4787. Arguments:        gadgets = first gadget in list of gadgets to refresh
  4788.             window = window containing gadgets
  4789.             requester = requester containing gadget; NULL if gadget is not
  4790.             part of a requester
  4791. Result:            none
  4792. -------------------------
  4793. RefreshGList
  4794. Description:        redraws a gadget and specified number of following gadgets in
  4795.             gadget list
  4796. Library:        intuition.library
  4797. Offset:            -$01BO (-432)
  4798. Modula-2 Module:    Intuition
  4799. Syntax:            RefreshGList(gadgets, window, requester, numGadgets)
  4800. C:            void RefreshGList(struct Gadget *, struct Window *, struct Re-
  4801.             quester *, long)
  4802. Machine Language:    RefreshGList(a0, a1, a2, d0)
  4803. Modula-2:        RefreshGList(gadgets: GadgetPtr; window: WindowPtr; requester:
  4804.             RequesterPtr; numGadgets: INTEGER)
  4805. Arguments:        gadgets = first gadget in list of gadgets to refresh
  4806.             window = window containing gadgets
  4807.             requester = requester containing gadget; NULL if gadget is not
  4808.             part of a requester
  4809.             numGadgets = number of gadgets to refresh; -1 to refresh to
  4810.             end of gadget list
  4811. Result:            none
  4812. -------------------------
  4813. RefreshWindowFrame
  4814. Description:        redraws a window's border, title bar, and gadgets
  4815. Library:        intuition.library
  4816. Offset:            -$01C8 (-456)
  4817. Modula-2 Module:    Intuition
  4818. Syntax:            RefreshWindowFrame(window)
  4819. C:            void RefreshWindowFrame(struct Window *)
  4820. Machine Language:    RefreshWindowFrame(a0)
  4821. Modula-2:        RefreshWindowFrame(window: WindowPtr)
  4822. Arguments:        window = window to refresh
  4823. Result:            none
  4824. ------------------------- 
  4825. ReleaseConfigBinding
  4826. Description:        allows others to bind drivers
  4827. Library:        expansion.library
  4828. Offset:            -$007E (-126)
  4829. Modula-2 Module:    none
  4830. Syntax:            ReleaseConfigBinding( )
  4831. C:            void ReleaseConfigBinding(void)
  4832. Machine Language:    ReleaseConfigBinding( )
  4833. Modula-2:        not available
  4834. Arguments:        none
  4835. Result:            none
  4836. -------------------------
  4837. ReleaseSemaphore
  4838. Description:        releases a signal semaphore for use by other tasks
  4839. Library:        exec.library
  4840. Offset:            -$023A (-5 70)
  4841. Modula-2 Module:    Semaphores
  4842. Syntax:            ReleaseSemaphore(signalSemaphore)
  4843. C:            void ReleaseSemaphore(struct SignalSemaphore *)
  4844. Machine Language:    ReleaseSemaphore(a0)
  4845. Modula-2:        ReleaseSemaphore(signalSemaphore: SignalSemaphorePtr)
  4846. Arguments:        signalSemaphore = initialized SignalSemaphore structure
  4847. Result:            none
  4848. -------------------------
  4849. ReleaseSemaphoreList
  4850. Description:        releases a list of signal semaphores for other tasks
  4851. Library:        exec.library
  4852. Offset:            -$024C (-588)
  4853. Modula-2 Module:    Semaphores
  4854. Syntax:            ReleaseSemaphoreList(list)
  4855. C:            void ReleaseSemaphoreList(struct List *)
  4856. Machine Language:    ReleaseSemaphoreList(a0)
  4857. Modula-2:        ReleaseSemaphoreList(list: SignalSemaphorePtr)
  4858. Arguments:        list = List structure representing a list of signal semaphores
  4859. Result:            none
  4860. -------------------------
  4861. RemakeDisplay
  4862. Description:        redraws every intuition screen
  4863. Library:        intuition.library
  4864. Offset:            -$0180 (-384)
  4865. Modula-2 Module:    Intuition
  4866. Syntax:            RemakeDisplay( )
  4867. C:            void RemakeDisplay(void)
  4868. Machine Language:    RemakeDisplay( )
  4869. Modula-2:        RemakeDisplay( )
  4870. Arguments:        none
  4871. Result:            none
  4872. -------------------------
  4873. RemBob (macro)
  4874. Description:        removes a Bob from current GEL list
  4875. C Include File:        include/graphics/gels.h
  4876. ML Include File:    graphics/gels.i
  4877. Modula-2 Module:    none
  4878. Syntax:            RemBob(bob, rastPort)
  4879. C:            void RemBob(struct Bob *, struct RastPort *)
  4880. Machine Language:    RemBob(a0)
  4881. Modula-2:        not available
  4882. Arguments:        bob = Bob structure to remove
  4883.             rastPort = controlling RastPort structure (not needed in
  4884.             Modula-2)
  4885. Result:            none
  4886. -------------------------
  4887. RemConfigDev
  4888. Description:        removes a ConfigDev structure from the system
  4889. Library:        expansion.library
  4890. Offset:            -$006C (-108)
  4891. Modula-2 Module:    ConfigVars
  4892. Syntax:            RemConfigDev(configDev)
  4893. C:            void RemConfigDev(long)
  4894. Machine Language:    RemConfigDev(a0)
  4895. Modula-2:        RemConfigDev(configDev: ConfigDevPtr)
  4896. Arguments:        configDev = ConfigDev structure
  4897. Result:            none
  4898. ------------------------- 
  4899. RemDevice
  4900. Description:        removes a device from the system
  4901. Library:        exec.library
  4902. Offset:            -$01B6 (-438)
  4903. Modula-2 Module:    Devices
  4904. Syntax:            error= RemDevice(device)
  4905. C:            long RemDevice(struct Device *)
  4906. Machine Language:    d0 = RemDevice(a1)
  4907. Modula-2:        RemDevice(device: DevicePtr)
  4908. Arguments:        device = device node
  4909. Result:            error = 0 if successful; nonzero if unsuccessful
  4910. -------------------------
  4911. RemFont
  4912. Description:        removes a font from the system
  4913. Library:        graphics.library
  4914. Offset:            -$01E6 (-486)
  4915. Modula-2 Module:    Text
  4916. Syntax:            error = RemFont(textFont)
  4917. C:            long RemFont(struct TextFont *)
  4918. Machine Language:    d0 = RemFont(a1)
  4919. Modula-2:        RemFont(textFont: TextFontPtr)
  4920. Arguments:        textFont = TextFont structure to remove
  4921. Result:            error = 0 if successful; nonzero if unsuccessful (no value returned
  4922.             by Modula-2)
  4923. -------------------------
  4924. RemHead
  4925. Description:        removes a node from the head of a list
  4926. Library:        exec.library
  4927. Offset:            -$0102 (-258)
  4928. Modula-2 Module:    Lists
  4929. Syntax:            node = RemHead(list)
  4930. C:            struct Node *RemHead(struct List *)
  4931. Machine Language:    d0 = RemHead(a0)
  4932. Modula-2:        RemHead(list: ListPtr): NodePtr
  4933. Arguments:        list = list header
  4934. Result:            node = node removed; NULL if list is was already empty
  4935. ------------------------- 
  4936. RemIBob
  4937. Description:        immediately removes a Bob from the GEL list and erases it from
  4938.             the RastPort display
  4939. Library:        graphics.library
  4940. Offset:            -$0084 (-132)
  4941. Modula-2 Module:    Gels
  4942. Syntax:            RemIBob(bob, rastPort, viewPort)
  4943. C:            void RemIBob(struct Bob *, struct RastPort *, struct ViewPort *)
  4944. Machine Language:    RemIBob(a0, a1, a2)
  4945. Modula-2:        RemIBob(bob: BobPtr; rastPort: RastPortPtr; viewPort:
  4946.             ViewPortPtr)
  4947. Arguments:        bob = Bob structure to remove from GEL list
  4948.             rastPort = RastPort structure
  4949.             viewPort = ViewPort structure
  4950. Result:            none
  4951. -------------------------
  4952. RemIntServer
  4953. Description:        removes an interrupt server from the system
  4954. Library:        exec.library
  4955. Offset:            -$00AE (-174)
  4956. Modula-2 Module:    Interrupts/
  4957. Syntax:            RemIntServer(intNum, interrupt)
  4958. C:            void RemIntServer(long, struct Interrupt *)
  4959. Machine Language:    RemIntServer(d0, a1)
  4960. Modula-2:        RemIntServer(intNum: CARDINAL; interrupt: InterruptPtr)
  4961. Arguments:        intNum = portia interrupt bit (0-4)
  4962.             interrupt = interrupt server node
  4963. Result:            none
  4964. -------------------------
  4965. RemLibrary
  4966. Description:        removes a library from the system
  4967. Library:        exec.library
  4968. Offset:            -$0192 (-402)
  4969. Modula-2 Module:    Libraries
  4970. Syntax:            error= RemLibrary(library)
  4971. C:            long RemLibrary(struct Library *)
  4972. Machine Language:    d0 = RemLibrary(a1)
  4973. Modula-2:        RemLibrary(Library: LibraryPtr)
  4974. Arguments:        library = Library structure to remove
  4975. Result:            error = 0 if successful; nonzero if unsuccessful
  4976. -------------------------
  4977. Remove
  4978. Description:        removes a node from a list
  4979. Library:        exec.library
  4980. Offset:            -$00FC (-252)
  4981. Modula-2 Module:    Lists
  4982. Syntax:            Remove(node)
  4983. C:            void Remove(struct Node *)
  4984. Machine Language:    Remove(a1)
  4985. Modula-2:        Remove(node: NodePtr)
  4986. Arguments:        node = node to remove
  4987. Result:            none
  4988. -------------------------
  4989. RemoveGadget      
  4990. Description:        removes gadget from a window
  4991. Library:        intuition.library
  4992. Offset:            -$00E4 (-228)
  4993. Modula-2 Module:    Intuition
  4994. Syntax:            position = RemoveGadget(window, gadget)
  4995. C:            long RemoveGadget(struct Window *, struct Gadget *)
  4996. Machine Language:    d0 = RemoveGadget(a0, a1)
  4997. Modula-2:        RemoveGadget(window: WindowPtr; gadget: GadgetPtr):
  4998.             INTEGER
  4999. Arguments:        window = window that contains gadget
  5000.             gadget = gadget to remove
  5001. Result:            position = position in gadget list where gadget was located; -1 if
  5002.             gadget was not found
  5003. -------------------------
  5004. RemoveGList
  5005. Description:        removes a series of gadgets from a gadget list
  5006. Library:        intuition.library
  5007. Offset:            -$01BC (-444)
  5008. Modula-2 Module:    Intuition
  5009. Syntax:            position = RemoveGList(window, gadget, numGadgets)
  5010. C:            long RemoveGList(struct Window *, Gadget *, long)
  5011. Machine Language:    d0 = RemoveGList(a0, a1, d0)
  5012.  
  5013. Modula-2:        RemoveGList(window: WindowPtr; gadget: GadgetPtr;
  5014.             numGadgets: INTEGER): INTEGER
  5015. Arguments:        window = window containing gadgets
  5016.             gadget = first gadget in gadget list to remove
  5017.             numGadgets = number of gadgets to remove
  5018. Result:            position = position of removed gadget list; -1 if gadget was not
  5019.             found
  5020. -------------------------
  5021. RemPort
  5022. Description:        removes a message port from the system
  5023. Library:        exec.library
  5024. Offset:            -$0168 (-360)
  5025. Modula-2 Module:    Ports
  5026. Syntax:            RemPort(port)
  5027. C:            void RemPort(struct MsgPort *)
  5028. Machine Language:    RemPort(a1)
  5029. Modula-2:        RemPort(port: MsgPortPtr)
  5030. Arguments:        port = message port to remove
  5031. Result:            none
  5032. -------------------------
  5033. RemResource
  5034. Description:        removes a resource from the system
  5035. Library:        exec.library
  5036. Offset:            -$01EC (-492)
  5037. Modula-2 Module:    Resources
  5038. Syntax:            RemResource(resource)
  5039. C:            void RemResource(struct Resource *)
  5040. Machine Language:    RemResource(a1)
  5041. Modula-2:        RemResource(resource: ResourcePtr)
  5042. Arguments:        resource = resource to remove
  5043. Result:            none
  5044. -------------------------
  5045. RemSemaphore
  5046. Description:        removes signal semaphore from the system
  5047. Library:        exec.library
  5048. Offset:            -$025E (-606)
  5049. Modula-2 Module:    Semaphores
  5050. Syntax:            RemSemaphore(signalSemaphore)
  5051. C:            void RemSemaphore(struct SignalSemaphore *)
  5052. Machine Language:    RemSemaphore(a1)
  5053. Modula-2:        RemSemaphore(signalSemaphore: SignalSemaphorePtr)
  5054. Arguments:        signalSemaphore = signal semaphore to remove
  5055. Result:            none
  5056. -------------------------
  5057. RemTail
  5058. Description:        removes node from the tail of a list
  5059. Library:        exec.library
  5060. Offset:            -$0108 (-264)
  5061. Modula-2 Module:    Lists
  5062. Syntax:            node = RemTail(list)
  5063. C:            struct Node *RemTail(struct List *)
  5064. Machine Language:    d0 = RemTail(a0)
  5065. Modula-2:        RemTail(list: ListPtr): NodePtr
  5066. Arguments:        list = list header
  5067. Result:            node = pointer to removed node; NULL if list is already empty
  5068. -------------------------
  5069. RemTask
  5070. Description:        removes a task from the system
  5071. Library:        exec.library
  5072. Offset:            -$0120 (-288)
  5073. Modula-2 Module:    Tasks
  5074. Syntax:            RemTask(task)
  5075. C:            void RemTask(struct Task *)
  5076. Machine Language:    RemTask(a1)
  5077. Modula-2:        RemTask(task: TaskPtr)
  5078. Arguments:        task = task to remove
  5079. Result:            none
  5080. -------------------------
  5081. RemTOF
  5082. Description:        removes a task from the TopOfFrame (vertical-blanking interval)
  5083.             interrupt server chain
  5084. Library:        amiga.lib (linked library)
  5085. Modula-2 Module:    none
  5086. Syntax:            RemTOF(i)
  5087. C:            void RemTOF(struct Isrvstr *)
  5088. Machine Language:    pea i
  5089.             jsr _RemTOF
  5090.             addq.l #4,sp
  5091. Modula-2:        not available
  5092. Arguments:        i = Isrvstr structure
  5093. Result:            none
  5094. -------------------------
  5095. RemVSprite
  5096. Description:        removes a VSprite from the GEL list
  5097. Library:        graphics.library
  5098. Offset:            -$008A (-138)
  5099. Modula-2 Module:    Gels
  5100. Syntax:            RemVSprite(vSprite)
  5101. C:            void RemVSprite(struct VSprite *)
  5102. Machine Language:    RemVSprite(a0)
  5103. Modula-2:        RemVSprite(vSprite: VSpritePtr)
  5104. Arguments:        vSprite = VSprite to remove
  5105. Result:            none
  5106. -------------------------
  5107. Rename
  5108. Description:        renames a directory or file
  5109. Library:        dos.library
  5110. Offset:            -$004E (-78)
  5111. Modula-2 Module:    DOS
  5112. Syntax:            success = Rename(oldName, newName)
  5113. C:            long Rename(char *, char *)
  5114. Machine Language:    d0 = Rename(d1, d2)
  5115. Modula-2:        Rename(oldName, newName: STRPTR): BOOLEAN
  5116. Arguments:        oldName = current name of file/directory (can include
  5117.             drive/directory path)
  5118.             newName = new name for file (can include drive/directory path)
  5119. Result:            success = TRUE if successful; FALSE if unsuccessful
  5120. -------------------------
  5121. ReplyMsg
  5122. Description:        replies to a message
  5123. Library:        exec.library
  5124. Offset:            -$017A (-378)
  5125. Modula-2 Module:    Ports
  5126. Syntax:            ReplyMsg(message)
  5127. C:            void ReplyMsg(struct MsgPort *)
  5128. Machine Language:    ReplyMsg(a1)
  5129. Modula-2:        ReplyMsg(message: ADDRESS)
  5130. Arguments:        message = message to reply to
  5131. Result:            none
  5132. -------------------------
  5133. ReportMouse
  5134. Description:        tells intuition whether or not to report the mouse movements as-
  5135.             sociated with a window
  5136. Library:        intuition.library
  5137. Offset:            -$00EA (-234)
  5138. Modula-2 Module:    Intuition
  5139. Syntax:            ReportMouse(window, flag)
  5140. C:            void ReportMouse(struct Window *, long)
  5141. Machine Language:    ReportMouse(a0, d0)
  5142. Modula-2:        ReportMouse(window: WindowPtr; flag: BOOLEAN)
  5143. Arguments:        window = window to be affected
  5144.             flag = TRUE to activate mouse movement reports; FALSE to stop
  5145.             mouse movement reports
  5146. Result:            none
  5147. -------------------------
  5148. Request
  5149. Description:        activates a requester
  5150. Library:        intuition.library
  5151. Offset:            -$00F0 (-240)
  5152. Modula-2 Module:    Intuition
  5153. Syntax:            success = Request(requester, window)
  5154. C:            long Request(struct Requester, struct Window *)
  5155. Machine Language:    d0 = Request(a0, a1)
  5156. Modula-2:        Request(requester: RequesterPtr; window: WindowPtr): BOOLEAN
  5157. Arguments:        requester = requester to display
  5158.             window = window in which requester will appear in
  5159. Result:            success = TRUE if successful; FALSE if unsuccessful
  5160. -------------------------
  5161. RethinkDisplay
  5162. Description:        performs a complete overhaul on the Intuition display-screens,
  5163.             ViewPorts, everything
  5164. Library:        intuition.library
  5165. Offset:            -$0186 (-390)
  5166. Modula-2 Module:    Intuition
  5167. Syntax:            RethinkDisplay( )
  5168. C:            void RethinkDisplay(void)
  5169. Machine Language:    RethinkDisplay( )
  5170. Modula-2:        RethinkDisplay( )
  5171. Arguments:        none
  5172. Result:            none
  5173. -------------------------
  5174. ScreenToBack
  5175. Description:        moves specified screen to back of the display
  5176. Library:        intuition.library
  5177. Offset:            -$00F6 (-246)
  5178. Modula-2 Module:    Intuition
  5179. Syntax:            ScreenToBack(screen)
  5180. C:            void ScreenToBack(struct Screen *)
  5181. Machine Language:    ScreenToBack(a0)
  5182. Modula-2:        ScreenToBack(screen: ScreenPtr)
  5183. Arguments:        screen = screen to move
  5184. Result:            none
  5185. -------------------------
  5186. ScreenToFront
  5187. Description:        moves specified screen to front of the display
  5188. Library:        intuition.library
  5189. Offset:            -$00FC (-252)
  5190. Modula-2 Module:    Intuition
  5191. Syntax:            ScreenToFront(screen)
  5192. C:            void ScreenToFront(struct Screen *)
  5193. Machine Language:    ScreenToFront(a0)
  5194. Modula-2:        ScreenToFront(screen: ScreenPtr)
  5195. Arguments:        screen = screen to move
  5196. Result:            none
  5197. -------------------------
  5198. ScrollLayer
  5199. Description:        copies data from a SuperBitMap to a layer so as to reposition the
  5200.             display over the bitmap
  5201. Library:        layers.library
  5202. Offset:            -$0048 (-72)
  5203. Modula-2 Module:    Layers
  5204. Syntax:            ScrollLayer(dummy, layer, dx, dy)
  5205. C:            void ScrollLayer(struct Layer_Info *, struct Layer *, long, long)
  5206. Machine Language:    ScrollLayer(a0, a1, d0, d1)
  5207. Modula-2:        ScrollLayer(layer: LayerPtr; dx, dy: LONGINT)
  5208. Arguments:        dummy = unused
  5209.             layer = Layer structure
  5210.             dx = offset by which to move layer horizontally
  5211.             dy = offset by which to move layer vertically
  5212. Result:            none
  5213. -------------------------
  5214. ScrollRaster
  5215. Description:        scrolls the contents of a rectangular area of a RastPort
  5216. Library:        graphics.library
  5217. Offset:            -$018C (-396)
  5218. Modula-2 Module:    Rasters
  5219. Syntax:            ScrollRaster(rastPort, dx, dy, x1, y1, x2, y2)
  5220. C:            void ScrollRaster(struct RastPort *, long, long, long, long, long, 
  5221.             long)
  5222. Machine Language:    ScrollRaster(a0, d0, d1, d2, d3, d4, d5)
  5223. Modula-2:        ScrollRaster(rastPort: RastPortPtr; dx, dy: INTEGER; x1, y1, x2,
  5224.             y2: INTEGER)
  5225. Arguments:        rastPort = RastPort structure
  5226.             dx = offset by which to scroll the rectangle
  5227.             dy = offset by which to scroll the rectangle
  5228.             x1 = horizontal position of the left edge of the rectangle
  5229.             y1 = vertical position of the top edge of the rectangle
  5230.             x2 = horizontal position of the right edge of the rectangle
  5231.             y2 = vertical position of the bottom edge of the rectangle
  5232. Result:            none
  5233. -------------------------
  5234. ScrollVPort
  5235. Description:        scrolls the contents of a rectangular area of a ViewPort by reinter-
  5236.             preting the RasInfo information in a ViewPort
  5237. Library:        graphics.library
  5238. Offset:            -$024C (-588)
  5239. Modula-2 Module:    Views
  5240. Syntax:            ScrollVPort(viewPort)
  5241. C:            void ScrollVPort(struct ViewPort *)
  5242. Machine Language:    ScrollVPort(a0)
  5243. Modula-2:        ScrollVPort(viewPort: ViewPortPtr)
  5244. Arguments:        viewPort = ViewPort structure to update
  5245. Result:            none
  5246. -------------------------
  5247. Seek
  5248. Description:        moves the file pointer to a specified position in a file
  5249. Library:        dos.library
  5250. Offset:            -$0042 (-66)
  5251. Modula-2 Module:    DOS
  5252. Syntax:            oldPosition = Seek(file, position, mode)
  5253. C:            long Seek(BPTR, long, long)
  5254. Machine Language:    d0 = Seek(d1, d2, d3)
  5255. Modula-2:        Seek(file: FileHandle; position: LONGINT; mode: LONGINT):
  5256.             LONGINT
  5257. Arguments:        file = BCPL pointer to a file handle
  5258.             position = offset by which to move file pointer
  5259.             mode = flag specifying how to interpret position offset-
  5260.             OFFSET_BEGINNING (-1), OFFSET_CURRENT (0), or
  5261.             OFFSET_END (1)
  5262. Result:            oldPosition = old file position; -1 if unsuccessful
  5263. -------------------------
  5264. SendIO
  5265. Description:        sends an IO request
  5266. Library:        exec.library
  5267. Offset:            -$01CE (-462)
  5268. Modula-2 Module:    IO
  5269. Syntax:            SendIO(ioRequest)
  5270. C:            void SendIO(struct IORequest *)
  5271. Machine Language:    SendIO(a1)
  5272. Modula-2:        SendIO(ioRequest: ADDRESS)
  5273. Arguments:        IORequest = an initialized IORequest structure
  5274. Result:            none
  5275. -------------------------
  5276. SetAfPt (macro)
  5277. Description:        sets area fill pattern
  5278. C Include File:        include/graphics/gfxmacros.h
  5279. ML Include File:    none
  5280. Modula-2 Module:    Pens
  5281. Syntax:            SetAfPt(rastPort, pattern, size)
  5282. C:            void SetAfPt(struct RastPort *, char *, long)
  5283. Machine Language:    not available
  5284. Modula-2:              SetAfPat(rastPort: RastPortPtr; pattern: ADDRESS; size:
  5285.             CARDINAL)
  5286. Arguments:        rastPort = RastPort structure
  5287.             pattern = pointer to the first word in an area-fill pattern
  5288.             size = size of area pattern (size to the power of two equals the
  5289.             number of words in pattern)
  5290. Result:            none
  5291. -------------------------
  5292. SetAPen
  5293. Description:        sets the primary pen color
  5294. Library:        graphics.library
  5295. Offset:            -0156 (-342)
  5296. Modula-2 Module:    Pens
  5297. Syntax:            SetAPen(rastPort, pen)
  5298. C:            void SetAPen(struct RastPort *, long)
  5299. Machine Language:    SetAPen(a1, d0)
  5300. Modula-2:        SetAPen(rastPort: RastPortPtr; pen: CARDINAL)
  5301. Arguments:        rastPort = RastPort structure
  5302.             pen = pen number (0-255)
  5303. Result:            none
  5304. -------------------------
  5305. SetBPen
  5306. Description:        sets the secondary pen color
  5307. Library:        graphics.library
  5308. Offset:            -015C (-348)
  5309. Modula-2 Module:    Drawing
  5310. Syntax:            SetBPen(rastPort, pen)
  5311. C:            void SetBPen(struct RastPort *, long)
  5312. Machine Language:    SetBPen(al, d0)
  5313. Modula-2:        SetBPen(rastPort: RastPortPtr; pen: CARDINAL)
  5314. Arguments:        rastPort = RastPort structure
  5315.             pen = pen number (0-255)
  5316. Result:            none
  5317. -------------------------
  5318. SetCollision
  5319. Description:        sets a collision vector to point to a user-written routine
  5320. Library:        graphics.library
  5321. Offset:            -0090 (-144)
  5322. Modula-2 Module:    Gels
  5323. Syntax:            SetCollision(number, routine, gelsInfo)
  5324. C:            void SetCollision(long, _fgptr, struct GelsInfo *)
  5325. Machine Language:    SetCollision(d0, a0, a1)
  5326. Modula-2:        SetCollision(number: LONGCARD; routine: PROC; gelsInfo:
  5327.             GelsInfoPtr)
  5328. Arguments:        number = collision vector number
  5329.             routine = pointer to user's collision routine
  5330.             gelsInfo = GelsInfo structure
  5331. Result:            none
  5332. -------------------------
  5333. SetComment
  5334. Description:        adds a comment to a file
  5335. Library:        dos.library
  5336. Offset:            -00B4 (-180)
  5337. Modula-2 Module:    DOS
  5338. Syntax:            success = SetComment(name, comment)
  5339. C:            long SetComment(char *, char *)
  5340. Machine Language:    d0 = SetComment(d1, d2)
  5341. Modula-2:        SetComment(name, comment: STRPTR): BOOLEAN
  5342. Arguments:        name = filename of file to comment
  5343.             comment = comment to add to file
  5344. Result:            success = TRUE if successful; FALSE if unsuccessful
  5345. -------------------------
  5346. SetCurrentBinding
  5347. Description:        sets static board configuration area
  5348. Library:        expansion.library
  5349. Offset:            -$0084 (-132)
  5350. Modula-2 Module:    none
  5351. Syntax:            SetCurrentBinding(currentBinding, size)
  5352. C:            void SetCurrentBinding(long, long)
  5353. Machine Language:    SetCurrentBinding(a0, d0)
  5354. Modula-2:              not available
  5355. Arguments:        currentBinding = CurrentBinding structure
  5356.             size = size of user's BindDriver structure
  5357. Result:            none
  5358. -------------------------
  5359. SetDMRequest
  5360. Description:        attaches a DMRequester (a requester activated when the mouse's
  5361.             menu button is double clicked) to a window
  5362. Library:        intuition.library
  5363. Offset:            -0102 (-258)
  5364. Modula-2 Module:    Intuition
  5365. Syntax:            success = SetDMRequest(window, dmRequester)
  5366. C:            long SetDMRequest(struct Window *, struct Requester *)
  5367. Machine Language:    d0 = SetDMRequest(a0, a1)
  5368. Modula-2:        SetDMRequest(window: WindowPtr; dmRequester: RequesterPtr)
  5369. Arguments:        window = window to which the requester will be added
  5370.             dmRequester = requester to attach
  5371. Result:            success = TRUE if successful; FALSE if unsuccessful (nothing re-
  5372.             turned by Modula-2)
  5373. -------------------------
  5374. SetDrMd
  5375. Description:        sets a drawing mode for drawing routines
  5376. Library:        graphics.library
  5377. Offset:            -0162 (-354)
  5378. Modula-2 Module:    Pens
  5379. Syntax:            SetDrMd(rastPort, mode)
  5380. C:            void SetDrMd(struct RastPort *, long)
  5381. Machine Language:    SetDrMd(a1, d0)
  5382. Modula-2:        SetDrMd(rastPort: RastPortPtr; mode: DrawingModeSet)
  5383. Arguments:        rastPort = RastPort structure
  5384.             mode = drawing mode JAM1, JAM2, COMPLEMENT,
  5385.             INVERSVID)
  5386. Result:            none
  5387. -------------------------
  5388. SetDrPt (macro)
  5389. Description:        sets a pattern to use for line drawing
  5390. C Include File:        include/graphics/gfxmacros.h
  5391. ML Include File:    none
  5392. Modula-2 Module:    Pens
  5393. Syntax:            SetDrPt(rastPort, pattern)
  5394. C:            void SetDrPt(struct RastPort *, long)
  5395. Machine Language:    not available
  5396. Modula-2:        SetDrPt(rastPort: RastPortPtr; pattern: BITSET)
  5397. Arguments:        rastPort = RastPort structure
  5398.             pattern = 16-bit drawing pattern
  5399. Result:            none
  5400. -------------------------
  5401. SetExcept
  5402. Description:        defines which signals cause an exception
  5403. Library:        exec.library
  5404. Offset:            -0138 (-312)
  5405. Modula-2 Module:    Tasks
  5406. Syntax:            oldSignals = SetExcept(newSignals, signalMask)
  5407. C:            long SetExcept(long, long)
  5408. Machine Language:    d0 = SetExcept(d0, d1)
  5409. Modula-2:        SetExcept(newSignals, signalMask: SignalSet): SignalSet
  5410. Arguments:        newSignals = new values for signals specified in signalMask
  5411.             signalMask = set of signals to be affected
  5412. Result:            oldSignals = prior exception signals
  5413. -------------------------
  5414. SetFont
  5415. Description:        sets the font to be used for drawing text in a rastport
  5416. Library:        graphics.library
  5417. Offset:            -0042 (-66)
  5418. Modula-2 Module:    Text
  5419. Syntax:            SetFont(rastPort, font)
  5420. C:            void SetFont(struct RastPort *, struct TextFont *)
  5421. Machine Language:    SetFont(a1/ a0)
  5422. Modula-2:        SetFont(rastPort: RastPortPtr; font: TextFontPtr)
  5423. Arguments:        rastPort = RastPort structure
  5424.             font = font descriptor obtained from OpenFont( ) function
  5425. Result:            none
  5426. -------------------------
  5427. SetFunction
  5428. Description:        changes a function vector in a library
  5429. Library:        exec.library
  5430. Offset:            -01A4 (-420)
  5431. Modula-2 Module:    Libraries
  5432. Syntax:            oldFunc = SetFunction(library, offset, newFunc)
  5433. C:            _fptr SetFunction(struct Library *, long,_fptr)
  5434. Machine Language:    d0 = SetFunction(a1, a0, d0)
  5435. Modula-2:        SetFunction(library: LibraryPtr; offset: INTEGER; newFunc:
  5436.             PROC): PROC
  5437. Arguments:        library = library to change
  5438.             offset = offset of function vector to change
  5439.             newFunc = address of new function
  5440. Result:            oldFunc = address of old function
  5441. -------------------------
  5442. SetIntVector
  5443. Description:        changes a system interrupt vector
  5444. Library:        exec.library
  5445. Offset:            -00A2 (-162)
  5446. Modula-2 Module:    Interrupts
  5447. Syntax:            oldInt = SetIntVector(intNum, newInt)
  5448. C:            struct Interrupt *SetIntVector(long, struct Interrupt *)
  5449. Machine Language:    d0 = SetIntVector(d0, a1)
  5450. Modula-2:        SetIntVector(intNum: CARDINAL; newInt: InterruptPtr):
  5451.             InterruptPtr
  5452. Arguments:        intNum = Portia interrupt bit number (0-14)
  5453.             newInt = initialized Interrupt structure
  5454. Result:            oldInt = old Interrupt structure
  5455. -------------------------
  5456. SetMenuStrip
  5457. Description:        attaches a menu strip to a window
  5458. Library:        intuition.library
  5459. Offset:            -0108 (-264)
  5460. Modula-2 Module:    Intuition
  5461. Syntax:            SetMenuStrip(window, menu)
  5462. C:            void SetMenuStrip(struct Window *, struct Menu *)
  5463. Machine Language:    SetMenuStrip(a0, a1)
  5464. Modula-2:        SetMenuStrip(window: WindowPtr; menu: MenuPtr)
  5465. Arguments:        window = window to receive menu strip
  5466.             menu = first menu in menu strip
  5467. Result:            none
  5468. -------------------------
  5469. SetOPen (macro)
  5470. Description:        sets the color of the pen used for outlining figures and tums on
  5471.             outlining
  5472. C Include File:        include/graphics/gfxmacros.h
  5473. ML Include File:    none
  5474. Modula-2 Module:    Pens
  5475. Syntax:            SetOPen(rastPort, pen)
  5476. C:            void SetOPen(struct RastPort *, long)
  5477. Machine Language:    not available
  5478. Modula-2:        SetOPen(rastPort: RastPortPtr; pen: CARDINAL)
  5479. Arguments:        rastPort = RastPort structure
  5480.             pen = pen number (0-255)
  5481. Result:            none
  5482. -------------------------
  5483. SetPointer
  5484. Description:        sets the shape of a window's sprite mouse pointer
  5485. Library:        intuition.library
  5486. Offset:            -010E (-270)
  5487. Modula-2 Module:    Intuition
  5488. Syntax:            SetPointer(window, pointer, height, width, xOffset, yOffset)
  5489. C:            void SetPointer(struct Window *, short *, long, long, long, long)
  5490. Machine Language:    SetPointer(a0, a1, d0, d1, d2, d3)
  5491. Modula-2:        SetPointer(window: WindowPtr; pointer: ADDRESS; height,
  5492.             width: CARDINAL; xOffset, y: INTEGER)
  5493. Arguments:        window = window to receive new pointer
  5494.             pointer = sprite data defining new shape
  5495.             height = height of sprite in lines
  5496.             width = width of sprite in pixels (less than or equal to 16)
  5497.             xOffset = horizontal offset of pointer hot spot
  5498.             yOffset = vertical offset of pointer hot spot
  5499. Result:            none
  5500. -------------------------
  5501. SetPrefs
  5502. Description:        changes Preferences' current settings
  5503. Library:        intuition.library
  5504. Offset:            -$0144 (-324)
  5505. Modula-2 Module:    Preferences
  5506. Syntax:            prefBuffer = SetPrefs(prefBuffer, size, inform)
  5507. C:            struct Preferences *SetPrefs(struct Preferences *, long, long)
  5508. Machine Language:    d0 = SetPrefs(a0, d0, d1)
  5509. Modula-2:        SetPrefs(prefBuffer: ADDRESS; size: INTEGER; inform:
  5510.             BOOLEAN)
  5511. Arguments:        prefBuffer = buffer which contains your desired Preferences
  5512.             settings
  5513.             size = size of buffer in bytes
  5514.             inform = TRUE if you want to send a NEWPREFS message to all
  5515.             interested windows
  5516. Result:            prefBuffer = pointer to your prefBuffer
  5517. ------------------------- 
  5518. SetProtection
  5519. Description:        sets a file or directories protection bits
  5520. Library:        dos.library
  5521. Offset:            -00BA (-186)
  5522. Modula-2 Module:    DOS
  5523. Syntax:            success = SetProtection(name, mask)
  5524. C:            long SetProtection(char *, long)
  5525. Machine Language:    d0 = SetProtection(d1, d2)
  5526. Modula-2:        SetProtection(name: STRPTR; mask: ProtectionSet): BOOLEAN
  5527. Arguments:        name = file or directory name
  5528.             mask = protection bits to set
  5529. Result:            success = TRUE if successful; FALSE if unsuccessful
  5530. -------------------------
  5531. SetRast
  5532. Description:        sets the entire rastport to a specified color
  5533. Library:        graphics.library
  5534. Offset:            -00EA (-234)
  5535. Modula-2 Module:    Rasters
  5536. Syntax:            SetRast(rastPort, pen)
  5537. C:            void SetRast(struct RastPort *, long)
  5538. Machine Language:    SetRast(a1, d0)
  5539. Modula-2:        SetRast(rastPort: RastPortPtr; pen: CARDINAL)
  5540. Arguments:        rastPort = RastPort structure
  5541.             pen = color register used to color the rastport (0-31)
  5542. Result:            none
  5543. -------------------------
  5544. SetRGB4
  5545. Description:        sets the red, green, and blue values for a viewport's color register
  5546. Library:        graphics.library
  5547. Offset:            -0120 (-288)
  5548. Modula-2 Module:    Views
  5549. Syntax:            SetRGB4(viewPort, pen, red, green, blue)
  5550. C:            void SetRGB4(struct ViewPort *, long, long, long, long)
  5551. Machine Language:    SetRGB4(a0, d0, d1, d2, d3)
  5552. Modula-2:        SetRGB4(viewPort: ViewPortPtr; pen: INTEGER; red, green, blue:
  5553.             CARDINAL)
  5554. Arguments:        viewPort = ViewPort structure
  5555.             pen = color register to set (0-31)
  5556.             red = red color level (0-15)
  5557.             green = green color level (0-15)
  5558.             blue = blue color level (0-15)
  5559. Result:            none
  5560. -------------------------
  5561. SetRGB4CM
  5562. Description:        sets the red, green, and blue values for a colormap's color register
  5563. Library:        graphics.library
  5564. Offset:            -0276 (-630)
  5565. Modula-2 Module:    Views
  5566. Syntax:            SetRGB4CM(colorMap, pen, red, green, blue)
  5567. C:            void SetRGB4CM(struct ColorMap *, long, long, long, long)
  5568. Machine Language:    SetRGB4CM(a0, d0, d1, d2, d3)
  5569. Modula-2:        SetRGB4CM(colorMap: ColorMapPtr; pen: INTEGER; red, green,
  5570.             blue: CARDINAL)
  5571. Arguments:        colorMap = ColorMap structure
  5572.             pen = color register to set (0-31)
  5573.             red = red color level (0-15)
  5574.             green = green color level (0-15)
  5575.             blue = blue color level (0-15)
  5576. Result:            none
  5577. -------------------------
  5578. SetSignal
  5579. Description:        defines the state of a task's signals
  5580. Library:        exec.library
  5581. Offset:            -0132 (-306)
  5582. Modula-2 Module:    Tasks
  5583. Syntax:            oldSignals = SetSignal(newSignals, signalMask)
  5584. C:            long SetSignal(long, long)
  5585. Machine Language:    d0 = SetSignal(d0, d1)
  5586. Modula-2:        SetSignal(newSignals, signalMask: SignalSet): SignalSet
  5587. Arguments:        newSignals = new values for signals specified in signalMask
  5588.             signalMask = set of signals to be affected
  5589. Result:            oldSignals = prior values for signals
  5590. ------------------------- 
  5591. SetSoftStyle
  5592. Description:        sets the style for the current font
  5593. Library:        graphics.library
  5594. Offset:            -005A (-90)
  5595. Modula-2 Module:    Text
  5596. Syntax:            newStyle = SetSoftStyle(rastPort, style, enable)
  5597. C:            long SetSoftStyle(struct RastPort *, long, long)
  5598. Machine Language:    d0 = SetSoftStyle(a1, d0, d1, a6)
  5599. Modula-2:        SetSoftStyle(rastPort: RastPortPtr; style, enable: FontStyleSet):
  5600.             FontStyleSet
  5601. Arguments:        rastPort = RastPort structure
  5602.             style = new font style
  5603.             enable = mask that determines which style bit can be changed;
  5604.             can be derived from AskSoftStyle( ) function
  5605. Result:            newStyle = resulting font style
  5606. -------------------------
  5607. SetSR
  5608. Description:        gets and/or sets the processor's status register
  5609. Library:        exec.library
  5610. Offset:            -0090 (-144)
  5611. Modula-2 Module:    Exec
  5612. Syntax:            oldSR = SetSR(newSR, mask)
  5613. C:            long SetSR(long, long)
  5614. Machine Language:    d0 = SetSR(d0, d1)
  5615. Modula-2:        SetSR(newSR: BITSET; mask: BITSET): BITSET
  5616. Arguments:        newSR = new value for bits specified in mask
  5617.             mask = bits to be affected
  5618. Result:            oldSR = prior value of status register
  5619. -------------------------
  5620. SetTaskPri
  5621. Description:        gets and sets the priority of a task
  5622. Library:        exec.library
  5623. Offset:            -012C (-300)
  5624. Modula-2 Module:    Tasks
  5625. Syntax:            oldPriority = SetTaskPri(task, newPriority)
  5626. C:            long SetTaskPri(struct Task *, long)
  5627. Machine Language:    d0 = SetTaskPri(a1, d0)
  5628. Modula-2:        SetTaskPri(task: TaskPtr; newPriority: INTEGER): INTEGER
  5629. Arguments:        task = task to be affected
  5630.             newPriority = new priority value (0-8)
  5631. Result:            oldPriority = old task priority (0-8)
  5632. -------------------------
  5633. SetWindowTitles
  5634. Description:        sets the titles for both a window and its screen
  5635. Library:        intuition.library
  5636. Offset:            -0114 (-276)
  5637. Modula-2 Module:    Intuition
  5638. Syntax:            SetWindowTitles(window, windowTitle, screenTitle)
  5639. C:            void SetWindowTitles(struct Window *, char *, char *)
  5640. Machine Language:    SetWindowTitles(a0, a1, a2)
  5641. Modula-2:        SetWindowTitles(window: WindowPtr; windowTitle, screenTitle:
  5642.             STRPTR)
  5643. Arguments:        window = window to be affected
  5644.             windowTitle = new window title (-1 to keep as-is)
  5645.             screenTitle = new screen title (-1 to keep as-is)
  5646. Result:            none
  5647. -------------------------
  5648. SetWrMsk (macro)
  5649. Description:        sets the write mask for a rastport (locks and unlocks bitplanes)
  5650. C Include File:    include/graphics/gfxmacros.h
  5651. ML Include File:    none
  5652. Modula-2 Module:    Pens
  5653. Syntax:            SetWrMsk(rastPort, mask)
  5654. C:            void SetWrMsk(struct RastPort *, long)
  5655. Arguments:        cList = character list containing substring
  5656.             index = starting position of substring
  5657.             length = number of bytes to copy
  5658. Result:            cList = new character list that contains the substring; -1 if there
  5659.             is not enough memory
  5660. -------------------------
  5661. SHIFTITEM (macro)
  5662. Description:        shifts a menu value to define a new value for the menu item
  5663.             number
  5664. C Include File:        include/intuition/intuition.h
  5665. ML Include File:    none
  5666. Modula-2 Module:    none
  5667. Syntax:            newValue = SHIFTITEM(menuValue)
  5668. C:            long SHIFTITEM(long)
  5669. Machine Language:    not available
  5670. Modula-2:        not available
  5671. Arguments:        menuValue = 16-bit packed number representing the menu num-
  5672.             ber, item number, and subitem number
  5673. Result:            newValue = the menuValue ANDed with $3F and shifted to the
  5674.             left five times-((menuValue & 0x3F) << 5)
  5675. -------------------------
  5676. SHIFTMENU (macro)
  5677. Description:        extracts the menu number from a value (identical to MENUNUM 
  5678.             macro)
  5679. C Include File:     include/intuition/intuition.h
  5680. ML Include File:     none
  5681. Modula-2 Module:    none
  5682. Syntax:            menuNumber= SHIFTMENU(menuValue)
  5683. C:            long SHIFTMENU(long)
  5684. Machine Language:    not available
  5685. Modula-2:        not available
  5686. Arguments:        menuValue = 16-bit packed number representing the menu num-
  5687.             ber, item number, and subitem number
  5688. Result:            menuNumber = menu number (0-31); equals NOMENU if no
  5689.             menu was selected
  5690. -------------------------
  5691. SHIFTSUB (macro)
  5692. Description:        shifts a menu value to define a new value for the menu subitem
  5693.             number
  5694. C Include File:        include/intuition/intuition.h
  5695. ML Include File:    none
  5696. Modula-2 Module:    none
  5697. Syntax:            newValue = SHIFTSUB(menuValue)
  5698. C:            long SHIFTSUB(long)
  5699. Machine Language:    not available
  5700. Modula-2:        not available
  5701. Arguments:        menuValue = 16-bit packed number representing the menu num-
  5702.             ber, item number, and subitem number
  5703. Result:            newValue = the menuValue ANDed with $1F and shifted to the
  5704.             left 11 times-((menuValue & 0x1F) << 11)
  5705. -------------------------
  5706. ShowTitle
  5707. Description:        determines whether the screen title bar will be displayed in front
  5708.             of a backdrop window
  5709. Library:        intuition.library
  5710. Offset:            -011A (-282) 
  5711. Modula-2 Module:    Intuition
  5712. Syntax:            ShowTitle(screen, showIt)
  5713. C:            void ShowTitle(struct Screen *, long)
  5714. Machine Language:    ShowTitle(a0, d0)
  5715. Modula-2:        ShowTitle(screen: ScreenPtr; showIt: BOOLEAN)
  5716. Arguments:        screen = screen to be affected
  5717.             showIt = flag that indicates whether or not to display the screen's
  5718.             title bar in front of a backdrop window (TRUE means show the
  5719.             title bar; FALSE means hide it)
  5720. Result:            none
  5721. -------------------------
  5722. Signal
  5723. Description:        signals a task with specified signals
  5724. Library:        exec.library
  5725. Offset:            -0144 (-324)
  5726. Modula-2 Module:    Tasks
  5727. Syntax:            Signal(task, signals)
  5728. C:            void Signal(struct Task *, long)
  5729. Machine Language:    Signal(d0, d1)
  5730. Modula-2:        Signal(task: TaskPtr; signals: SignalSet)
  5731. Arguments:        task = task to be signaled
  5732.             signals = signals to send
  5733. Result:            none
  5734. -------------------------
  5735. SizeCList
  5736. Description:        gets the size of a character list in bytes
  5737. Library:        clist.library
  5738. Offset:            -0036 (-54)
  5739. Modula-2 Module:    none
  5740. Syntax:            size = SizeCList(cList)
  5741. C:            long SizeCList(long)
  5742. Machine Language:    d0 = SizeCList(a0)
  5743. Modula-2:              not available
  5744. Arguments:        cList = character list in question
  5745. Result:            size = number of bytes in character list
  5746. -------------------------
  5747. SizeLayer
  5748. Description:        changes the size of a nonbackdrop layer
  5749. Library:        layers.library
  5750. Offset:            -0042 (-66)
  5751. Modula-2 Module:    Layers
  5752. Syntax:            SizeLayer(dummy, layer, dx, dy)
  5753. C:            long SizeLayer(struct Layer_Info *, struct Layer *, long, long)
  5754. Machine Language:    d0 = SizeLayer(a0, a1, d0, d1)
  5755. Modula-2:        SizeLayer(layer: LayerPtr; dx, dy: LONGINT): BOOLEAN
  5756. Arguments:        dummy = unused
  5757.             layer = a nonbackdrop Layer structure
  5758.             dx = amount to add to layer's horizontal size (may be negative)
  5759.             dy = amount to add to layer's vertical size (may be negative)
  5760. Result:            TRUE if successful; FALSE if unsuccessful
  5761. -------------------------
  5762. SizeWindow
  5763. Description:        resizes a window
  5764. Library:        intuition.library
  5765. Offset:            -0120 (-288)
  5766. Modula-2 Module:    Intuition
  5767. Syntax:            SizeWindow(window, dx, dy)
  5768. C:            void SizeWindow(struct Window *, long, long)
  5769. Machine Language:    SizeWindow(a0, d0, d1)
  5770. Modula-2:        SizeWindow(window: WindowPtr; dx, dy: INTEGER)
  5771. Arguments:        window = window to be resized
  5772.             dx = amount to add to window's horizontal size (may be
  5773.             negative)
  5774.             dy = amount to add to window's vertical size (may be negative)
  5775. Result:            none
  5776. -------------------------
  5777. SortGList
  5778. Description:        sorts the GEL list by vertical position of each element, prior to
  5779.             displaying the GELs
  5780. Library:        graphics.library
  5781. Offset:            -0096 (-150)
  5782. Modula-2 Module:    Gels
  5783. Syntax:            SortGList(rastPort)
  5784. C:            void SortGList(struct RastPort *)
  5785. Machine Language:    SortGList(a1)
  5786. Modula-2:        SortGList(rastPort: RastPortPtr)
  5787. Arguments:        rastPort = RastPort structure containing the GelsInfo
  5788. Result:            none
  5789. -------------------------
  5790. SPAbs
  5791. Description:        obtains the absolute value of a floating-point number
  5792. Library:        mathffp.library
  5793. Offset:            -$0036 (-54)
  5794. Modula-2 Module:    none
  5795. Syntax:            fnum1 = SPAbs(fnum2)
  5796. C:            float SPAbs(float)
  5797. Machine Language:    d0 = SPAbs(d0)
  5798. Modula-2:        not available
  5799. Arguments:        fnum2 = floating-point number
  5800. Result:            fnum1 = absolute value of fnum2 in floating-point format
  5801. -------------------------
  5802. SPAcos
  5803. Description:        obtains the arcosine of a floating-point number
  5804. Library:        mathtrans.library
  5805. Offset:            -$0078 (-120)
  5806. Modula-2 Module:    none
  5807. Syntax:            fnum1 = SPAcos(fnum2)
  5808. C:            float SPAcos(float)
  5809. Machine Language:    d0 = SPAcos(d0)
  5810. Modula-2:        not available
  5811. Arguments:        fnum2 = floating-point number representing the cosine of an
  5812.             angle
  5813. Result:            fnum1 = floating-point value of fnum2 angle in radians
  5814. -------------------------
  5815. SPAdd
  5816. Description:        adds two floating-point numbers
  5817. Library:        mathffp.library
  5818. Offset:            -$0042 (-66)
  5819. Modula-2 Module:    none
  5820. Syntax:            fnum1 = SPAdd(fnum2, fnum3)
  5821. C:            float SPAdd(float, float)
  5822. Machine Language:    d0 = SPAdd(d1, d0)
  5823. Modula-2:        not available
  5824. Arguments:        fnum2 = floating-point number
  5825.             fnum3 = floating-point number
  5826. Result:            fnum1 = fnum2 plus fnum3 in floating-point format
  5827. -------------------------
  5828. SPAsin
  5829. Description:        obtains the arcsine of a floating-point number
  5830. Library:        mathtrans.library
  5831. Offset:            -$0072 (-114)
  5832. Modula-2 Module:    none
  5833. Syntax:            fnum1 = SPAsin(fnum2)
  5834. C:            float SPAsin(float)
  5835. Machine Language:    d0 = SPAsin(d0)
  5836. Modula-2:        not available
  5837. Arguments:        fnum2 = floating-point number representing the sine of an angle
  5838. Result:            fnum1 = floating-point value of fnum2 angle in radians
  5839. -------------------------
  5840. SPAtan
  5841. Description:        obtains the arctangent of a floating-point number
  5842. Library:        mathtrans.library
  5843. Offset:            -$0030 (-48)
  5844. Modula-2 Module:    none
  5845. Syntax:            fnum1 = SPAtan(fnum2)
  5846. C:            float SPAtan(float)
  5847. Machine Language:    d0 = SPAtan(d0)
  5848. Modula-2:        not available
  5849. Arguments:        fnum2 = floating-point number representing the tangent of an
  5850.             angle
  5851. Result:            fnum1 = floating-point value of fnum2 angle in radians
  5852. -------------------------
  5853. SPCmp
  5854. Description:        compares two floating-point numbers
  5855. Library:        mathffp.library
  5856. Offset:            -$002A (-42)
  5857. Modula-2 Module:    none
  5858. Syntax:            flag = SPCmp(fnum1, fnum2)
  5859. C:            long SPCmp(float, float)
  5860. Machine Language:    d0 = SPCmp(d1, d0)
  5861. Modula-2:        not available
  5862. Arguments:        fnum1 = floating-point number
  5863.             fnum2 = floating-point number
  5864. Result:            flag = -1 if fnum1<fnum2; +1 if fnum1>fnum2; 0 if
  5865.             fnum1 = fnum2
  5866. -------------------------
  5867. SPCos
  5868. Description:        obtains the cosine of a floating-point number
  5869. Library:        mathtrans.library
  5870. Offset:            -$002A (-42)
  5871. Modula-2 Module:    none
  5872. Syntax:            fnum1 = SPCos(fnum2)
  5873. C:            float SPCos(float)
  5874. Machine Language:    d0 = SPCos(d0)
  5875. Modula-2:        not available
  5876. Arguments:        fnum2 = floating-point number representing an angle in radians
  5877. Result:            fnum1 = floating-point cosine of fnum2
  5878. -------------------------
  5879. SPCosh
  5880. Description:        obtains the hyperbolic cosine of a floating-point number
  5881. Library:        mathtrans.library
  5882. Offset:            -$0042 (-66)
  5883. Modula-2 Module:    none
  5884. Syntax:            fnum1 = SPCosh(fnum2)
  5885. C:            float SPCosh(float)
  5886. Machine Language:    d0 = SPCosh(d0)
  5887. Modula-2:        not available
  5888. Arguments:        fnum2 = floating-point number representing an angle in radians
  5889. Result:            fnum1 = floating-point hyperbolic cosine of fnum2
  5890. -------------------------
  5891. SPDiv
  5892. Description:        divides one floating-point number by another
  5893. Library:        mathffp.library
  5894. Offset:            -$0054 (-84)
  5895. Modula-2 Module:    none
  5896. Syntax:            fnum1 = SPDiv(fnum2, fnum3)
  5897. C:            float SPDiv(float, float)
  5898. Machine Language:    d0 = SPDiv(d1, d0)
  5899. Modula-2:        not available
  5900. Arguments:        fnum2 = floating-point dividend
  5901.             fnum3 = floating-point divisor
  5902. Result:            fnum1 = floating-point format results of fnum2 divided by fnum3
  5903. -------------------------
  5904. SPExp
  5905. Description:        obtains the exponent of a floating-point number
  5906. Library:        mathtrans.library
  5907. Offset:            -$004E (-78)
  5908. Modula-2 Module:    none
  5909. Syntax:            fnum1 = SPExp(fnum2)
  5910. C:            float SPExp(float)
  5911. Machine Language:    d0 = SPExp(d0)
  5912. Modula-2:        not available
  5913. Arguments:        fnum2 = floating-point number
  5914. Result:            fnum1 = floating-point value representing e (approx. 2.71728)
  5915.             raised to the power of fnum2
  5916. -------------------------
  5917. SPFieee
  5918. Description:        converts a single-precision IEEE number to a Motorola fast float-
  5919.             ing point number
  5920. Library:        mathtrans.library
  5921. Offset:            -$006C (-108)
  5922. Modula-2 Module:    none
  5923. Syntax:            fnum = SPFieee(ieeenum)
  5924. C:            float SPFieee(long)
  5925. Machine Language:    d0 = SPFieee(d0)
  5926. Modula-2:        not available
  5927. Arguments:        ieeenum = single-precision floating-point number
  5928. Result:            fnum = Motorola fast floating point equivalent to fnum
  5929. -------------------------
  5930. SPFlt
  5931. Description:        converts an integer to floating-point number
  5932. Library:        mathffp.library
  5933. Offset:            -$0024 (-36)
  5934. Modula-2 Module:    none
  5935. Syntax:            fnum = SPFlt(inum)
  5936. C:            float SPFlt(long)
  5937. Machine Language:    d0 = SPFlt(d0)
  5938. Modula-2:        not available
  5939. Arguments:        inum = signed integer to be converted
  5940. Result:            fnum = floating-point equivalent to inum
  5941. -------------------------
  5942. SplitCList
  5943. Description:        splits a character list in two, breaking it at the mark (obtained via
  5944.             the MarkList( ) function)
  5945. Library:        clist.library
  5946. Offset:            -008A (-138)
  5947. Modula-2 Module:    none
  5948. Syntax:            tailCList = SplitCList(cList)
  5949. C:            long SplitCList(long)
  5950. Machine Language:    d0 = SplitCList(a0)
  5951. Modula-2:        not available
  5952. Arguments:        cList = character list to split
  5953. Result:            tailCList = new character list that contains the tail end of the
  5954.             original character list; -1 if there is not enough memory
  5955. -------------------------
  5956. SPLog
  5957. Description:        obtains the natural logarithm of a floating-point number
  5958. Library:        mathtrans.library
  5959. Offset:            -$0054 (-84)
  5960. Modula-2 Module:    none
  5961. Syntax:            fnum1 = SPLog(fnum2)
  5962. C:            float SPLog(float)
  5963. Machine Language:    d0 = SPLog(d0)
  5964. Modula-2:        not available
  5965. Arguments:        fnum2 = floating-point number
  5966. Result:            fnum1 = floating-point natural logarithm (base e) of fnum2
  5967. -------------------------
  5968. SPLog10
  5969. Description:        obtains the naparian logarithm (base 10) of a floating-point number
  5970. Library:        mathtrans.library
  5971. Offset:            -$007E (-126)
  5972. Modula-2 Module:    none
  5973. Syntax:            fnum1 = SPLog10(fnum2)
  5974. C:            float SPLoglO(float)
  5975. Machine Language:    d0 = SPLog10(d0)
  5976. Modula-2:      not available
  5977. Arguments:        fnum2 = floating-point number
  5978. Result:            fnum1 = floating-point naparian logarithm (base 10) of fnum2
  5979. -------------------------
  5980. SPMul
  5981. Description:        multiplies one floating-point number by another
  5982. Library:        mathffp.library
  5983. Offset:            -$004E (-78)
  5984. Modula-2 Module:    none
  5985. Syntax:            fnum1 = SPMul(fnum2, fnum3)
  5986. C            float SPMul(float, float)
  5987. Machine Language:    d0 = SPMul(d1, d0)
  5988. Modula-2:        not available
  5989. Arguments:        fnum2 = floating-point number
  5990.             fnum3 = floating-point number
  5991. Result:            fnum1 = product of fnum2 and fnum3 in floating-point format
  5992. -------------------------
  5993. SPNeg
  5994. Description:        negates the value of a floating-point number
  5995. Library:        mathffp.library
  5996. Offset:            -$003C (-60)
  5997. Modula-2 Module:    none
  5998. Syntax:            fnum1 = SPNeg(fnum2)
  5999. C:            float SPNeg(float)
  6000. Machine Language:    d0 = SPNeg(d0)
  6001. Modula-2:        not available
  6002. Arguments:        fnum2 = floating-point number to negate
  6003. Result:            fnum1 = negative fnum2 in floating-point format
  6004. -------------------------
  6005. SPPow
  6006. Description:        obtains the exponentiation of two floating-point numbers
  6007. Library:        mathtrans.library
  6008. Offset:            -$005A (-90)
  6009. Modula-2 Module:    none
  6010. Syntax:            fnum1 = SPPow(fnum2, fnum3)
  6011. C:            float SPPow(float, float)
  6012. Machine Language:    d0 = SPPow(d1, d0)
  6013. Modula-2:        not available
  6014. Arguments:        fnum2 = floating-point number
  6015.             fnum3 = floating-point number
  6016. Result:            fnum1 = floating-point value of fnum2 raised to the power of
  6017.             fnum3
  6018. -------------------------
  6019. sprintf
  6020. Description:        outputs a formatted string into a string (Lattice and Manx users: if 
  6021.             you link with lc.lib or c.lib, this is not the function you're calling)
  6022. Library:        amiga.lib (linked library)
  6023. Modula-2 Module:    none
  6024. Syntax:            sprintf(destinationString, formatString, values...)
  6025. C:            void sprintf(char *, char *, long...)
  6026. Machine Language:    move.l #value,-(sp) ;may have several values 
  6027.             pea formatString 
  6028.             pea destinationString 
  6029.             jsr _printf 
  6030.             add.l #8,sp ;(2 arguments * 4 bytes = 8)
  6031. Modula-2:        not available
  6032.  
  6033. Arguments:        destinationString = address of string to receive output
  6034.              formatString = string containing optional C formatting commands
  6035.              (%); if you're passing longword values on the stack (as shown
  6036.              above) be sure to follow the percent symbol with a lowercase L
  6037.              values = values or addresses of strings to print; this routine
  6038.              knows how many values are on the stack by checking the number
  6039.              of formatting commands in formatString argument
  6040. Result:             none
  6041. -------------------------
  6042. SPSin
  6043. Description:         obtains the sine of a floating-point number
  6044. Library:         mathtrans.library
  6045. Offset:             -$0024 (-36)
  6046. Modula-2 Module:    none
  6047. Syntax:            fnum1 = SPSin(fnum2)
  6048. C:            float SPSin(float, float)
  6049. Machine Language:    d0 = SPSin(d0)
  6050. Modula-2:         not available
  6051. Arguments:        fnum2 = floating-point number representing an angle in radians
  6052. Result:            fnum1 = floating-point sine of fnum2
  6053. -------------------------
  6054. SPSincos
  6055. Description:         obtains the sine and cosine of a floating-point number
  6056. Library:         mathtrans.library
  6057. Offset:             -$0036 (-54)
  6058. Modula-2 Module:    none
  6059. Syntax:            fnum1 = SPSincos(fnum2, fnum3)
  6060. C:            float SPSincos(float, float *)
  6061. Machine Language:    d0 = SPSincos(d1, d0)
  6062. Modula-2:        not available
  6063. Arguments:        fnum2 = floating-point number
  6064.             fnum3 = pointer to floating point number to receive the cosine of
  6065.             fnum2
  6066. Result:            fnum1 = floating-point sine of fnum2 (cosine is returned in
  6067.             fnum3)
  6068. -------------------------
  6069. SPSinh
  6070. Description:        obtains the hyperbolic sine of a floating-point number
  6071. Library:        mathtrans.library
  6072. Offset:            -$003C (-60)
  6073. Modula-2 Module:    none
  6074. Syntax:            fnum1 = SPSinh(fnum2)
  6075. C:            float SPSinh(float, float)
  6076. Machine Language:    d0 = SPSinh(d0)
  6077. Modula-2:        not available
  6078. Arguments:        fnum2 = floating-point number representing an angle in radians
  6079. Result:            fnum1 = floating-point hyperbolic sine of fnum2
  6080. -------------------------
  6081. SPSqrt
  6082. Description:        obtains the square root of a floating-point number
  6083. Library:        mathtrans.library
  6084. Offset:            -$0060 (-96)
  6085. Modula-2 Module:    none
  6086. Syntax:            fnum1 = SPSqrt(fnum2)
  6087. C:            float SPSqrt(float)
  6088. Machine Language:    d0 = SPSqrt(d0)
  6089. Modula-2:        not available
  6090. Arguments:        fnum2 = floating-point number
  6091. Result:            fnum1 = floating-point square root of fnum2
  6092. -------------------------
  6093. SPSub
  6094. Description:        subtracts one floating-point number from another
  6095. Library:        mathffp.library
  6096. Offset:            -$0048 (-72)
  6097. Modula-2 Module:    none
  6098. Syntax:            fnum1 = SPSub(fnum2, fnum3)
  6099. C:            float SPSub(float, float)
  6100. Machine Language:    d0 = SPSub(d1, d0)
  6101. Modula-2:        not available
  6102. Arguments:        fnum2 = floating-point number
  6103.             fnum3 = floating-point number
  6104. Result:            fnum1 = fnum2 minus fnum3 in floating-point format
  6105. -------------------------
  6106. SPTan
  6107. Description:        obtains the tangent of a floating-point number
  6108. Library:        mathtrans.library
  6109. Offset:            -$0030 (-48)
  6110. Modula-2 Module:    none
  6111. Syntax:            fnum1 = SPTan(fnum2)
  6112. C:            float SPTan(float, float)
  6113. Machine Language:    d0 = SPTan(d0)
  6114. Modula-2:        not available
  6115. Arguments:        fnum2 = floating-point number representing an angle in radians
  6116. Result:            fnum1 = floating-point tangent of fnum2
  6117. -------------------------
  6118. SPTanh
  6119. Description:        obtains the hyperbolic tangent of a floating-point number
  6120. Library:        mathtrans.library
  6121. Offset:            -$0048 (-72)
  6122. Modula-2 Module:    none
  6123. Syntax:            fnum1 = SPTanh(fnum2)
  6124. C:            float SPTanh(float, float)
  6125. Machine Language:    d0 = SPTanh(d0)
  6126. Modula-2:        not available
  6127. Arguments:        fnum2 = floating-point number representing an angle in radians
  6128. Result:            fnum1 = floating-point hyperbolic tangent of fnum2
  6129. -------------------------
  6130. SPTieee
  6131. Description:        converts a Motorola fast floating point number to a single-
  6132.             precision IEEE number
  6133. Library:        mathtrans.library
  6134. Offset:            -$0066 (-102)
  6135. Modula-2 Module:    none
  6136. Syntax:            ieeenum = SPTieee(fnum)
  6137. C:            float SPTieee(float)
  6138. Machine Language:    d0 = SPTieee(d0)
  6139. Modula-2:        not available
  6140. Arguments:        fnum = Motorola fast floating point number
  6141. Result:            ieeenum = single-precision floating-point equivalent to fnum
  6142. -------------------------
  6143. SPTst
  6144. Description:        compares a floating-point number with zero
  6145. Library:        mathffp.library
  6146. Offset:            -$0030 (-48)
  6147. Modula-2 Module:    none
  6148. Syntax:            flag = SPTst(fnum)
  6149. C:            long SPTst(float)
  6150. Machine Language:    d0 = SPTst(d0)
  6151. Modula-2:        not available
  6152. Arguments:        fnum = floating-point number
  6153. Result:            flag = -1 if fnum<0; +1 if fnum>0; 0 if fnum=0
  6154. -------------------------
  6155. SubCList
  6156. Description:        copies a substring from a character list
  6157. Library:        clist.library
  6158. Offset:            -0096 (-150)
  6159. Modula-2 Module:    none
  6160. Syntax:            cList = SubCList(cList, index, length)
  6161. C:            long SubCList(long, long, long)
  6162. Machine Language:    d0 = SubCList(a0, d0, d1)
  6163. Modula-2:        not available
  6164. Arguments:        cList = character list containing substring
  6165.             index = starting position of substring
  6166.             length = number of bytes to copy
  6167. Result:            cList = new character list that contains the substring; -1 if there
  6168.             is not enough memory
  6169. -------------------------
  6170. SUBNUM (macro)
  6171. Description:        extracts the menu subitem number from a value
  6172. C Include File:        include/intuition/intuition.h
  6173. ML Include File:    none
  6174. Modula-2 Module:    Intuition
  6175. Syntax:            subNumber= SUBNUM(menuValue)
  6176. C:            long SUBNUM(long)
  6177. Machine Language:    not available
  6178. Modula-2:        SUBNUM(menuValue: CARDINAL): CARDINAL
  6179. Arguments:        menuValue = 16-bit packed number representing the menu num-
  6180.             ber, item number, and subitem number
  6181. Result:            itemNumber = item number (0-31); equals NOSUB if no menu
  6182.             was selected
  6183. -------------------------
  6184. SumKickData
  6185. Description:        computes the checksum for a Kickstart delta list
  6186. Library:        exec.library
  6187. Offset:            -0264 (-612)
  6188. Modula-2 Module:    Resident
  6189. Syntax:            SumKickData( )
  6190. C:            void SumKickData(void)
  6191. Machine Language:    SumKickData( )
  6192. Modula-2:        SumKickData( )
  6193. Arguments:        none
  6194. Result:            none
  6195. -------------------------
  6196. SumLibrary
  6197. Description:        verifies a library's checksum; alerts user if checksum is incorrect
  6198. Library:        exec.library
  6199. Offset:            -01AA (-426)
  6200. Modula-2 Module:    Libraries
  6201. Syntax:            SumLibrary(library)
  6202. C:            void SumLibrary(struct Library *)
  6203. Machine Language:    SumLibrary(a1)
  6204. Modula-2:        SumLibrary(
  6205. Library:        LibraryPtr)
  6206. Arguments:        library = library to verify
  6207. Result:            none
  6208. -------------------------
  6209. SuperState
  6210. Description:        engage supervisor mode using user-defined stack
  6211. Library:        exec.library
  6212. Offset:            -$0096 (-150)
  6213. Modula-2 Module:    Interrupts
  6214. Syntax:            sysStack = SuperState( )
  6215. C:            long SuperState(void)
  6216. Machine Language:    d0 = SuperState( ) 
  6217. Modula-2:        SuperState( ): ADDRESS 
  6218. Arguments:        none 
  6219. Result:            sysStack = pointer to system stack; NULL if already in supervisor 
  6220.             mode
  6221. -------------------------
  6222. SwapBitsRastPortClipRect
  6223. Description:        engage supervisor mode using user-defined stack
  6224. Library:        layers.library
  6225. Offset:            -007E (-126)
  6226. Modula-2 Module:    Layers
  6227. Syntax:            SwapBitsRastPortClipRect(rastPort, clipRect)
  6228. C:            void SwapBitsRastPortClipRect(struct RastPort *, struct ClipRect *)
  6229. Machine Language:    SwapBitsRastPortClipRect(a0, a1)
  6230. Modula-2:        SwapBitsRastPortClipRect(rastPort: RastPortPtr; clipRect:
  6231.             ClipRectPtr)
  6232. Arguments:        rastPort = RastPort structure
  6233.             clipRect = ClipRect to swap bits with
  6234. Result:            none
  6235. -------------------------
  6236. SyncSBitMap
  6237. Description:        copies all bits from a layer's ClipRects into the SuperBitMap
  6238. Library:        layers.library
  6239. Offset:            -01BC (-444)
  6240. Modula-2 Module:    Clip
  6241. Syntax:            SyncSBitMap(layer)
  6242. C:            void SyncSBitMap(struct Layer *)
  6243. Machine Language:    SyncSBitMap(a0)
  6244. Modula-2:        SyncSBitMap(layer: LayerPtr)
  6245. Arguments:        layer = a locked layer that contains a SuperBitMap
  6246. Result:            none
  6247. -------------------------
  6248. Text
  6249. Description:        prints text in a RastPort using the current font
  6250. Library:        graphics.library
  6251. Offset:            -$003C (-60)
  6252. Modula-2 Module:    Text
  6253. Syntax:            Text(rastPort, string, length)
  6254. C:            void Text(struct RastPort *, char *, long)
  6255. Machine Language:    Text(a1, a0, d0)
  6256. Modula-2:        Text(rastPort: RastPortPtr; string: STRPTR; length: CARDINAL)
  6257. Arguments:        rastPort = RastPort where text is to be output
  6258.             string = text to print
  6259.             length = number of characters in string
  6260. Result:            none
  6261. -------------------------
  6262. Textlength
  6263. Description:        finds the length (in bits) that a string of characters would occupy
  6264.             if printed to a RastPort using the current text font
  6265. Library:        graphics.library
  6266. Offset:            -$0036 (-54)
  6267. Modula-2 Module:    Text
  6268. Syntax:            size = TextLength(rastPort, string, length)
  6269. C:            long TextLength(struct RastPort *, char *, long)
  6270. Machine Language:    d0 = TextLength(a1, a0, d0)
  6271. Modula-2:        TextLength(rastPort: RastPortPtr; string: STRPTR; length: CARDI-
  6272.             NAL): CARDINAL
  6273. Arguments:        rastPort = RastPort where text would be output
  6274.             string = text to print
  6275.             length = number of characters in string
  6276. Result:            size = number of pixels (horizontally) required to print the speci-
  6277.             fied text
  6278. -------------------------
  6279. ThinLayerInfo
  6280. Description:        converts a 1.1 LayerInfo structure into a 1.0 LayerInfo structure,
  6281.             thus returning the extra memory allocate by FattenLayerInfo (this
  6282.             is an obsolete function)
  6283. Library:        layers.library
  6284. Offset:            -$00A2 (-162)
  6285. Modula-2 Module:    none
  6286. Syntax:            ThinLayerInfo(layerInfo)
  6287. C:            void ThinLayerInfo(struct Layer_Info *)
  6288. Machine Language:    ThinLayerInfo(a0)
  6289. Modula-2:        not available
  6290. Arguments:        layerInfo = LayerInfo structure to convert
  6291. Result:            none
  6292. ------------------------- 
  6293. Translate
  6294. Description:        converts an English string into phonetics
  6295. Library:        translator.library
  6296. Offset:            -$001E (-30)
  6297. Modula-2 Module:    Translator
  6298. Syntax:            error = Translate(instring, inlen, outbuf, outlen)
  6299. C:            long Translate(char *, long, char *, long)
  6300. Machine Language:    d0 = Translate(a1, d0, a1, d1)
  6301. Modula-2:        Translate(instring: STRPTR; inlen: LONGCARD; outbuf: STRPTR;
  6302.             outlen: LONGCARD): LONGINT
  6303. Arguments:        instring = English string to convert
  6304.             inlen = number of characters in instring
  6305.             outbuf = buffer to hold phonetic codes
  6306.             outlen = size of outbuf in bytes
  6307. Result:            error = 0 if successful; negative number representing position in
  6308.             instring where function was forced to stop because the output
  6309.             buffer overflowed
  6310. -------------------------
  6311. TypeOfMem
  6312. Description:        determines the attributes of a given memory address
  6313. Library:        exec.library
  6314. Offset:            -$0216 (-534)
  6315. Modula-2 Module:    Memory
  6316. Syntax:            attributes = TypeOfMem(address)
  6317. C:            long TypeOfMem(void *)
  6318. Machine Language:    d0 = TypeOfMem(a0)
  6319. Modula-2:        TypeOfMem(address: ADDRESS): MemReqSet
  6320. Arguments:        address = memory address
  6321. Result:            attributes = type of memory-MEMF_CHIP, MEMF_FAST,
  6322.             MEMF_PUBLIC
  6323. -------------------------
  6324. UnGetCLChar
  6325. Description:        adds a byte to the beginning of a character list
  6326. Library:        clist.library
  6327. Offset:            -$0048 (-72)
  6328. Modula-2 Module:    none
  6329. Syntax:            error = UnGetCLChar(cList, byte)
  6330. C:            long UnGetCLChar(long, long)
  6331. Machine Language:    d0 = UnGetCLChar(a0, d0)
  6332. Modula-2:        not available
  6333. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  6334.             StrToCL( )
  6335.             byte = byte to add to beginning of character list
  6336. Result:            error = 0 if successful
  6337. -------------------------
  6338. UnGetCLWord
  6339. Description:        adds a word to the beginning of a character list
  6340. Library:        clist.library
  6341. Offset:            -$0060 (-96)
  6342. Modula-2 Module:    none
  6343. Syntax:            error = UnGetCLWord(cList, word)
  6344. C:            long UnGetCLWord(long, long)
  6345. Machine Language:    d0 = UnGetCLWord(a0, d0)
  6346. Modula-2:        not available
  6347. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  6348.             StrToCL( )
  6349.             word = word to add to beginning of character list
  6350. Result:            error = 0 if successful; 1 if unsuccessful
  6351. -------------------------
  6352. UnLoadSeg
  6353. Description:        removes a segment from memory
  6354. Library:        dos.library
  6355. Offset:            -$009C (-156)
  6356. Modula-2 Module:    DOSLoader
  6357. Syntax:            UnLoadSeg(segment)
  6358. C:            void UnLoadSeg(BPTR)
  6359. Machine Language:    UnLoadSeg(d1)
  6360. Modula-2:        UnLoadSeg(segment: BPTR): BOOLEAN
  6361. Arguments:        segment = BCPL pointer to a segment as returned by LoadSeg( )
  6362. Result:            none
  6363. -------------------------
  6364. UnLock
  6365. Description:        unlocks a directory or file
  6366. Library:        dos.library
  6367. Offset:            -$005A (-90)
  6368. Modula-2 Module:    DOS
  6369. Syntax:            UnLock(lock)
  6370. C:            void UnLock(BPTR)
  6371. Machine Language:    UnLock(d1)
  6372. Modula-2:        UnLock(lock: FileLock)
  6373. Arguments:        lock = BCPL pointer to a lock
  6374. Result:            none
  6375. -------------------------
  6376. UnlockIBase
  6377. Description:        releases the lock on IntuitionBase so Intuition can change the
  6378.             structure as it pleases
  6379. Library:        intuition.library
  6380. Offset:            -$01A4 (-420)
  6381. Modula-2 Module:    IntuitionBase
  6382. Syntax:            UnLockIBase(lockNumber)
  6383. C:            void UnLockIBase(long)
  6384. Machine Language:    UnLockIBase(a0)
  6385. Modula-2:        UnLockIBase(lockNumber: LONGCARD)
  6386. Arguments:        lockNumber = Intuition lock value as returned by LockIBase( )
  6387. Result:            none
  6388. -------------------------
  6389. UnlockLayer
  6390. Description:        unlocks a Layer so the graphics routines can use it
  6391. Library:        layers.library
  6392. Offset:            -$0066 (-102)
  6393. Modula-2 Module:    Layers
  6394. Syntax:            UnLockLayer(layer)
  6395. C:            void UnLockLayer(struct Layer *)
  6396. Machine Language:    UnLockLayer(a0)
  6397. Modula-2:        UnLockLayer(layer: LayerPtr)
  6398. Arguments:        layer = Layer structure to unlock
  6399. Result:            none
  6400. -------------------------
  6401. UnlockLayerInfo
  6402. Description:        unlocks a Layer_Info structure
  6403. Library:        layers.library
  6404. Offset:            -$008A (-138)
  6405. Modula-2 Module:    Layers
  6406. Syntax:            UnlockLayerInfo(layerlnfo)
  6407. C:            void UnlockLayerInfo(struct Layer_Info *)
  6408. Machine Language:    UnlockLayerInfo(a0, a1)
  6409. Modula-2:        UnlockLayerInfo(layerlnfo: LayerlnfoPtr)
  6410. Arguments:        layerlnfo = Layer_Info structure to unlock
  6411. Result:            none
  6412. -------------------------
  6413. UnlockLayerRom
  6414. Description:        unlocks a Layer so the graphics routines can use it (this function
  6415.             uses ROM code as opposed to LockLayerRom( )'s RAM-based
  6416.             code)
  6417. Library:        graphics.library
  6418. Offset:            -$01B6 (-438)
  6419. Modula-2 Module:    RomLayers
  6420. Syntax:            UnLockLayerRom(layer)
  6421. C:            void UnLockLayerRom(struct Layer *)
  6422. Machine Language:    UnLockLayerRom(a5)
  6423. Modula-2:        UnLockLayerRom(layer: LayerPtr)
  6424. Arguments:        layer = Layer structure to unlock
  6425. Result:            none
  6426. -------------------------
  6427. UnlockLayers
  6428. Description:        unlocks all layers so the graphics routines can use them
  6429. Library:        layers.library
  6430. Offset:            -$0072 (-114)
  6431. Modula-2 Module:    Layers
  6432. Syntax:            UnLockLayers(layerInfo)
  6433. C:            void UnLockLayers(struct Layer_Info *)
  6434. Machine Language:    UnLockLayers(a0)
  6435. Modula-2:        UnLockLayers(layerInfo: LayerInfoPtr)
  6436. Arguments:        layerInfo = Layer_Info structure
  6437. Result:            none
  6438. -------------------------
  6439. UnPutCLChar
  6440. Description:        gets a byte from the end of a character list
  6441. Library:        clist.library
  6442. Offset:            -$0048 (-72)
  6443. Modula-2 Module:    none
  6444. Syntax:            byte= UnPutCLChar(cList)
  6445. C:            long UnPutCLChar(long)
  6446. Machine Language:    d0 = UnPutCLChar(a0)
  6447. Modula-2:        not available
  6448. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  6449.             StrToCL( )
  6450. Result:            byte = byte from end of character list; -1 no data
  6451. -------------------------
  6452. UnPutCLWord
  6453. Description:        gets a word from the end of a character list
  6454. Library:        clist.library
  6455. Offset:            -$0066 (-102)
  6456. Modula-2 Module:    none
  6457. Syntax:            word = UnPutCLWord(cList)
  6458. C:            long UnPutCLWord(long)
  6459. Machine Language:    d0 = UnPutCLWord(a0)
  6460. Modula-2:        not available
  6461. Arguments:        cList = character list descriptor, as returned by AllocCList( ) or
  6462.             StrToCL( )
  6463. Result:            word = word from end of character list; -1 if no data
  6464. -------------------------
  6465. UpFrontLayer
  6466. Description:        moves a layer in front of all other layers
  6467. Library:        layers.library
  6468. Offset:            -$0030 (-48)
  6469. Modula-2 Module:    Layers
  6470. Syntax:            success = UpFrontLayer(dummy, layer)
  6471. C:            long UpFrontLayer(struct Layer_Info *, struct Layer *)
  6472. Machine Language:    d0 = UpFrontLayer(a0, a1)
  6473. Modula-2:        UpfrontLayer(layer: LayerPtr): BOOLEAN
  6474. Arguments:        dummy = unused
  6475.             layer = pointer to Layer to move behind other layers
  6476. Result:            success = TRUE if successful; FALSE if unsuccessful
  6477. -------------------------
  6478. UserState
  6479. Description:        return to user state and system stack (do NOT call if computer is
  6480.             already in user state)
  6481. Library:        exec.library
  6482. Offset:            -009C (-156)
  6483. Modula-2 Module:    Interrupts
  6484. Syntax:            UserState(sysStack)
  6485. C:            void UserState(char *)
  6486. Machine Language:    UserState(d0)
  6487. Modula-2:        UserState(sysStack: ADDRESS)
  6488. Arguments:        sysStack = system stack pointer as returned by SuperState( )
  6489. Result:            none
  6490. -------------------------
  6491. Vacate
  6492. Description:        releases a semaphore locked by Procure( )
  6493. Library:        exec.library
  6494. Offset:            -$0222 (-546)
  6495. Modula-2 Module:    Semaphores
  6496. Syntax:            Vacate(semaphore)
  6497. C:            void Vacate(struct Semaphore *)
  6498. Machine Language:    Vacate(a0)
  6499. Modula-2:        Vacate(semaphore: SemaphorePtr)
  6500. Arguments:        semaphore = Semaphore structure to release
  6501. Result:            none
  6502. -------------------------
  6503. VBeamPos
  6504. Description:        returns the current position of the vertical video beam
  6505. Library:        graphics.library
  6506. Offset:            -$0180 (-384)
  6507. Modula-2 Module:    Views
  6508. Syntax:            pos = VBeamPos( )
  6509. C:            long VBeamPos(void)
  6510. Machine Language:    d0 = VBeamPos( )
  6511. Modula-2:        VBeamPos( ): CARDINAL
  6512. Arguments:        none
  6513. Result:            pos = current beam position (0-511)
  6514. -------------------------
  6515. ViewAddress
  6516. Description:        returns the address of Intuition's View structure
  6517. Library:        intuition.library
  6518. Offset:            -$0126 (-294)
  6519. Modula-2 Module:    Intuition
  6520. Syntax:            view = ViewAddress( )
  6521. C:            struct View *ViewAddress(void)
  6522. Machine Language:    d0 = ViewAddress( )
  6523. Modula-2:        ViewAddress( ): ViewPtr
  6524. Arguments:        none
  6525. Result:            view = address of the Intuition View structure
  6526. ------------------------- 
  6527. ViewPortAddress
  6528. Description:        returns the address of a window's ViewPort structure
  6529. Library:        intuition.library
  6530. Offset:            -$012C (-300)
  6531. Modula-2 Module:    Intuition
  6532. Syntax:            viewPort = ViewPortAddress(window)
  6533. C:            struct ViewPort *ViewPortAddress(struct Window *)
  6534. Machine Language:    d0 = ViewPortAddress(a0)
  6535. Modula-2:        ViewPortAddress(window: WindowPtr): ViewPortPtr
  6536. Arguments:        window = Window structure
  6537. Result:            viewPort = address of window's ViewPort structure
  6538. -------------------------
  6539. Wait
  6540. Description:        waits for one or more signals
  6541. Library:        exec.library
  6542. Offset:            -$013E (-318)
  6543. Modula-2 Module:    Tasks
  6544. Syntax:            signals = Wait(signalSet)
  6545. C:            long Wait(long)
  6546. Machine Language:    d0 = Wait(d0)
  6547. Modula-2:        Wait(signalSet: SignalSet): SignalSet
  6548. Arguments:        signalSet = set of signals to wait for
  6549. Result:            signals = signals that have occurred
  6550. -------------------------
  6551. WaitBlit
  6552. Description:        waits for the blitter to finish what it's doing
  6553. Library:        graphics.library
  6554. Offset:            -$00E4 (-228)
  6555. Modula-2 Module:    Blitter
  6556. Syntax:            WaitBlit( )
  6557. C:            void WaitBlit(void)
  6558. Machine Language:    WaitBlit( )
  6559. Modula-2:        WaitBlit( )
  6560. Arguments:        none
  6561. Result:            none
  6562. ------------------------- 
  6563. WaitBOVP
  6564. Description:        waits for the vertical beam to reach the bottom of a ViewPort
  6565. Library:        graphics.library
  6566. Offset:            -$0192 (-402)
  6567. Modula-2 Module:    Views
  6568. Syntax:            WaitBOVP(viewPort)
  6569. C:            void WaitBOVP(struct ViewPort *)
  6570. Machine Language:    WaitBOVP(a0)
  6571. Modula-2:        WaitBOVP(viewPort: ViewPortPtr)
  6572. Arguments:        viewPort = ViewPort structure
  6573. Result:            none
  6574. -------------------------
  6575. WaitForChar
  6576. Description:        waits a specified amount of time for a character to become avail-
  6577.             able from a virtual terminal
  6578. Library:        dos.library
  6579. Offset:            -$00CC (-204)
  6580. Modula-2 Module:    DOS
  6581. Syntax:            avail = WaitForChar(file, timeout)
  6582. C:            long WaitForChar(BPTR, long)
  6583. Machine Language:    d0 = WaitForChar(d1, d2)
  6584. Modula-2:        WaitForChar(file: FileHandle; timeout: LONGINT): BOOLEAN
  6585. Arguments:        file = BCPL pointer to a file handle
  6586.             timeout = number of microseconds to wait for character
  6587. Result:            avail = TRUE if a character is available
  6588. -------------------------
  6589. WaitIO
  6590. Description:        waits for an I/O request to be executed
  6591. Library:        exec.library
  6592. Offset:            -$01DA (-474)
  6593. Modula-2 Module:    IO
  6594. Syntax:            error = WaitIO(ioRequest)
  6595. C:            long WaitIO(struct IORequest *)
  6596. Machine Language:    d0 = WaitIO(a1)
  6597. Modula-2:        WaitIO(ioRequest: ADDRESS): INTEGER
  6598. Arguments:        ioRequest = IORequest block
  6599. Result:            error = 0 if successful
  6600. -------------------------
  6601. WaitPort
  6602. Description:        waits for a message
  6603. Library:        exec.library
  6604. Offset:            -$0180 (-384)
  6605. Modula-2 Module:    Ports
  6606. Syntax:            message = WaitPort(port)
  6607. C:            struct Message *WaitPort(struct MsgPort *)
  6608. Machine Language:    d0 = WaitPort(a0)
  6609. Modula-2:        WaitPort(port: MsgPortPtr): ADDRESS
  6610. Arguments:        port = message port to receive message
  6611. Result:            message = pointer to first available message
  6612. -------------------------
  6613. WaitTOF
  6614. Description:        waits for the next vertical blank
  6615. Library:        graphics.library
  6616. Offset:            -$010E (-270)
  6617. Modula-2 Module:    Views
  6618. Syntax:            WaitTOF( )
  6619. C:            void WaitTOF(void)
  6620. Machine Language:    WaitTOF( )
  6621. Modula-2:        WaitTOF( )
  6622. Arguments:        none
  6623. Result:            none
  6624. -------------------------
  6625. WBenchToBack
  6626. Description:        moves the Workbench screen behind all other screens
  6627. Library:        intuition.library
  6628. Offset:            -$0150 (-336)
  6629. Modula-2 Module:    Intuition
  6630. Syntax:            success = WBenchToBack( )
  6631. C:            long WBenchToBack(void)
  6632. Machine Language:    d0 = WBenchToBack( )
  6633. Modula-2:        WBenchToBack( ): BOOLEAN
  6634. Arguments:        none
  6635. Result:            success = TRUE if Workbench screen is open
  6636. -------------------------
  6637. WBenchToFront
  6638. Description:        moves the Workbench screen in front of all other screens
  6639. Library:        intuition.library
  6640. Offset:            -$0156 (-342)
  6641. Modula-2 Module:    Intuition
  6642. Syntax:            success = WBenchToFront( )
  6643. C:            long WBenchToFront(void)
  6644. Machine Language:    d0 = WBenchToFront( )
  6645. Modula-2:        WBenchToFront( ): BOOLEAN
  6646. Arguments:        none
  6647. Result:            success = TRUE if Workbench screen is open
  6648. -------------------------
  6649. WhichLayer
  6650. Description:        finds the layer which contains the specified point
  6651. Library:        layers.library
  6652. Offset:            -$0084 (-132)
  6653. Modula-2 Module:    Layers
  6654. Syntax:            layer = WhichLayer(layerlnfo, x, y)
  6655. C:            struct Layer *WhichLayer(struct Layer_Info *, long, long)
  6656. Machine Language:    d0 = WhichLayer(a0, d0, d1)
  6657. Modula-2:        WhichLayer(layerlnfo: LayerlnfoPtr; x, y: LONGCARD): LayerPtr
  6658. Arguments:        layerlnfo = Layerlnfo structure
  6659.             x = horizontal coordinate of point
  6660.             y = vertical coordinate of point
  6661. Result:            layer = pointer to top-most layer containing this point; NULL if
  6662.             point is not in a layer
  6663. -------------------------
  6664. WindowLimits
  6665. Description:        sets the minimum and maximum size of a window
  6666. Library:        intuition.library
  6667. Offset:            -$013E (-318)
  6668. Modula-2 Module:    Intuition
  6669. Syntax:            success = WindowLimits(window, minWidth, minHeight,
  6670.             maxWidth, minHeight)
  6671. C:            long WindowLimits(struct Window *, long, long, long, long)
  6672. Machine Language:    d0 = WindowLimits(a0, d0, d1, d2, d3)
  6673. Modula-2:        WindowLimits(window: WindowPtr; minWidth, minHeight,
  6674.             maxWidth, maxHeight: LONGINT): BOOLEAN
  6675. Arguments:        window = window to set size limits for
  6676.             minWidth = window's new minimum width
  6677.             minHeight = window's new minimum height
  6678.             maxWidth = window's new maximum width
  6679.             maxHeight = window's new minimum height
  6680. Result:            success = TRUE if all limits are set; FALSE if any of the limits are
  6681.             out of range, in which case only the legal limits are set
  6682. -------------------------
  6683. WindowToBack
  6684. Description:        moves a window to the back of all other windows
  6685. Library:        intuition.library
  6686. Offset:            -$0132 (-306)
  6687. Modula-2 Module:    Intuition
  6688. Syntax:            WindowToBack(window)
  6689. C:            void WindowToBack(struct Window *)
  6690. Machine Language:    WindowToBack(a0)
  6691. Modula-2:        WindowToBack(window: WindowPtr)
  6692. Arguments:        window = window to move to back of display
  6693. Result:            none
  6694. -------------------------
  6695. WindowToFront
  6696. Description:        moves a window in front of all other windows
  6697. Library:        intuition.library
  6698. Offset:            -$0138 (-312)
  6699. Modula-2 Module:    Intuition
  6700. Syntax:            WindowToFront(window)
  6701. C:            void WindowToFront(struct Window *)
  6702. Machine Language:    WindowToFront(a0)
  6703. Modula-2:        WindowToFront(window: WindowPtr)
  6704. Arguments:        window = window to move to front of display
  6705. Result:            none
  6706. -------------------------
  6707. Write
  6708. Description:        writes bytes of data to a file
  6709. Library:        dos.library
  6710. Offset:            -$0030 (-48)
  6711. Modula-2 Module:    DOS
  6712. Syntax:            length = Write(file, buffer, length)
  6713. C:            long Write(BPTR, char *, long)
  6714. Machine Language:    d0 = Write(d1, d2, d3)
  6715. Modula-2:        Write(file: FileHandle; buffer: ADDRESS; length: LONGINT):
  6716.             LONGINT
  6717. Arguments:        file = BCPL pointer to a file handle
  6718.             buffer = pointer to start of buffer containing data to write
  6719.             length = number of bytes to write
  6720. Result:            length = number of bytes successfully written; -1 if error
  6721.             occurred
  6722. -------------------------
  6723. WriteExpansionByte
  6724. Description:        writes a byte to a new-style memory expansion board-nybble by
  6725.             nybble
  6726. Library:        expansion.library
  6727. Offset:            -$0072 (-114)
  6728. Modula-2 Module:    Expansion
  6729. Syntax:            error = WriteExpansionByte(board, offset, byte)
  6730. C:            long WriteExpansionByte(long, long, long)
  6731. Machine Language:    d0 = WriteExpansionByte(a0, d0, d1)
  6732. Modula-2:        WriteExpansionByte(board: ADDRESS; offset: LONGCARD; byte:
  6733.             BYTE): BOOLEAN
  6734. Arguments:        board = base of a new-style expansion board
  6735.             offset = logical offset from the configdev base
  6736.             byte = byte to write to board
  6737. Result:            error = 0 if successful
  6738. -------------------------
  6739. WritePixel
  6740. Description:        colors a single pixel with the current foreground drawing pen
  6741. Library:        graphics.library
  6742. Offset:            -$0144 (-324)
  6743. Modula-2 Module:    Pens
  6744. Syntax:            error = WritePixel(rastPort, x, y)
  6745. C:            long WritePixel(struct RastPort *, long, long)
  6746. Machine Language:    d0 = WritePixel(a1, d0, d1 )
  6747. Modula-2:        WritePixel(rastPort: RastPortPtr; x, y: INTEGER): INTEGER
  6748. Arguments:        rastPort = RastPort structure containing pixel to color
  6749.             x = horizontal coordinate of pixel
  6750.             y = vertical coordinate of pixel
  6751. Result:            error = 0 if successful; -1 if pixel is outside specified RastPort
  6752. -------------------------
  6753. XorRectRegion
  6754. Description:        performs a 2d XOR operation of a rectangle with a region, leaving
  6755.             the results in the region
  6756. Library:        graphics.library
  6757. Offset:            -$022E (-558)
  6758. Modula-2 Module:    Regions
  6759. Syntax:            status = XorRectRegion(region, rectangle)
  6760. C:            long XorRectRegion(struct Region *, struct Rectangle *)
  6761. Machine Language:    d0 = XorRectRegion(a0, a1)
  6762. Modula-2:        XorRectRegion(region: RegionPtr; rectangle: RectanglePtr):
  6763.             BOOLEAN
  6764. Arguments:        region = Region structure
  6765.             rectangle = Rectangle structure
  6766. Result:            status = TRUE if successful; FALSE if out of memory
  6767. -------------------------
  6768. XorRegionRegion
  6769. Description:        performs a 2d XOR operation of one region with a second region,
  6770.             leaving the results in the second region
  6771. Library:        graphics.library
  6772. Offset:            -$026A (-618)
  6773. Modula-2 Module:    Regions
  6774. Syntax:            status = XorRegionRegion(region1, region2)
  6775. C:            long XorRegionRegion(struct Region *, struct Region *)
  6776. Machine Language:    d0 = XorRegionRegion(a0, a1)
  6777. Modula-2:        XorRegionRegion(region1, region2: RegionPtr): BOOLEAN
  6778. Arguments:        region1 = Region structure
  6779.             region2 = Region structure
  6780. Result:            status = TRUE if successful; FALSE if out of memory
  6781. -------------------------